text stringlengths 8 4.13M |
|---|
#[cfg(feature = "new")]
extern crate new_abi_stable as abi_stable;
#[cfg(not(feature = "new"))]
extern crate old_abi_stable as abi_stable;
use abi_stable::{library::RootModule, marker_type::NonOwningPhantom, sabi_types::VersionStrings};
mod many_types {
use std::{marker::PhantomData, sync::atomic};
use abi_stable::{
external_types::{
crossbeam_channel::{RReceiver, RSender},
RMutex, ROnce, RRwLock,
},
marker_type,
prefix_type::PrefixRef,
std_types::*,
};
#[repr(C)]
#[derive(abi_stable::StableAbi)]
pub struct ManyTypes(
&'static mut (),
&'static mut i32,
&'static (),
&'static i32,
&'static &'static (),
&'static mut &'static (),
&'static &'static mut (),
atomic::AtomicPtr<()>,
atomic::AtomicPtr<i32>,
*const (),
*const i32,
*mut (),
*mut i32,
[(); 0],
[(); 1],
[(); 2],
[(); 3],
[u32; 3],
i32,
u32,
bool,
atomic::AtomicBool,
atomic::AtomicIsize,
atomic::AtomicUsize,
std::num::NonZeroU32,
std::num::NonZeroU16,
std::ptr::NonNull<()>,
std::ptr::NonNull<i32>,
RHashMap<RString, RString>,
RHashMap<RString, i32>,
RHashMap<i32, RString>,
RHashMap<i32, i32>,
RVec<()>,
RVec<i32>,
RSlice<'static, ()>,
RSlice<'static, i32>,
RSliceMut<'static, ()>,
RSliceMut<'static, i32>,
Option<&'static ()>,
Option<&'static u32>,
Option<extern "C" fn()>,
ROption<()>,
ROption<u32>,
RCowStr<'static>,
RCowSlice<'static, u32>,
RArc<()>,
RArc<u32>,
RBox<()>,
RBox<u32>,
RBoxError,
SendRBoxError,
UnsyncRBoxError,
RCmpOrdering,
PhantomData<()>,
PhantomData<RString>,
RMutex<()>,
RMutex<RString>,
RRwLock<()>,
RRwLock<RString>,
RSender<()>,
RSender<RString>,
RReceiver<()>,
RReceiver<RString>,
ROnce,
marker_type::SyncSend,
marker_type::UnsyncUnsend,
marker_type::UnsyncSend,
marker_type::SyncUnsend,
marker_type::NotCopyNotClone,
marker_type::ErasedObject<u32>,
marker_type::ErasedObject<RString>,
PrefixRef<marker_type::ErasedPrefix>,
marker_type::UnsafeIgnoredType<u32>,
marker_type::NonOwningPhantom<u32>,
marker_type::NonOwningPhantom<RString>,
f32,
f64,
);
}
pub use many_types::ManyTypes;
#[repr(C)]
#[derive(abi_stable::StableAbi)]
#[sabi(kind(Prefix(prefix_ref = RootMod_Ref)))]
#[sabi(missing_field(panic))]
pub struct RootMod {
pub abi_stable_version: VersionStrings,
pub _marker: NonOwningPhantom<many_types::ManyTypes>,
}
impl RootModule for RootMod_Ref {
abi_stable::declare_root_module_statics! {RootMod_Ref}
const BASE_NAME: &'static str = "version_compatibility_impl";
const NAME: &'static str = "version_compatibility_impl";
const VERSION_STRINGS: VersionStrings = abi_stable::package_version_strings!();
}
|
use crate::{
error::Error,
model::{CreateUser, User},
service::Service,
};
use async_std::sync::{Arc, RwLock};
use async_trait::async_trait;
use core::cmp::max;
#[derive(Clone)]
pub struct MockService {
users: Arc<RwLock<Vec<User>>>,
}
impl MockService {
pub fn new() -> Self {
MockService {
users: Arc::new(RwLock::new(vec![])),
}
}
}
#[async_trait]
impl Service for MockService {
async fn create_user(&self, user: CreateUser) -> Result<User, Error> {
let users = self.users.clone();
let mut users = users.write().await;
let next_id =
users.iter().map(|user| user.id).fold(0, |x, y| max(x, y)) + 1;
let user = User {
id: next_id,
name: user.name,
};
users.push(user.clone());
Ok(user)
}
async fn list_users(&self) -> Result<Vec<User>, Error> {
Ok(self.users.clone().read().await.clone())
}
async fn get_user(&self, user_id: i32) -> Result<Option<User>, Error> {
Ok(self
.users
.clone()
.read()
.await
.iter()
.find(|user| user.id == user_id)
.map(|user| user.clone()))
}
async fn delete_user(&self, user_id: i32) -> Result<bool, Error> {
let users = self.users.clone();
let mut users = users.write().await;
let exists = users.iter().find(|user| user.id == user_id).is_some();
users.retain(|user| user.id != user_id);
Ok(exists)
}
}
|
// Copyright 2022 Datafuse Labs.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::backtrace::Backtrace;
use std::sync::Arc;
use common_arrow::arrow_format::flight::data::FlightData;
use common_exception::exception::ErrorCodeBacktrace;
use common_exception::ErrorCode;
use common_exception::Result;
#[test]
fn test_serialize() -> Result<()> {
let error_code = ErrorCode::create(
1,
String::from("test_message"),
None,
Some(ErrorCodeBacktrace::Origin(Arc::new(Backtrace::capture()))),
)
.set_span(Some((0..1).into()));
let backtrace_str = error_code.backtrace_str();
let error_code = ErrorCode::try_from(FlightData::from(error_code))?;
assert_eq!(1, error_code.code());
assert_eq!(String::from("test_message"), error_code.message());
assert_eq!(backtrace_str, error_code.backtrace_str());
assert_eq!(error_code.span(), Some((0..1).into()));
Ok(())
}
|
use std::io::{Read, Write};
use codecs::{ToByte, FromByte};
use error::{Error, Result};
use utils::TopicPartitionOffset;
use super::{HeaderRequest, HeaderResponse};
use super::{API_KEY_OFFSET_FETCH, API_KEY_OFFSET_COMMIT, API_VERSION};
//
// XXX Seems like this got replaced: See https://cwiki.apache.org/confluence/pages/diffpages.action?originalId=61329518&pageId=61330213
//
// #[derive(Debug)]
// pub struct ConsumerMetadataRequest<'a> {
// pub header: HeaderRequest<'a>,
// pub group: &'a str,
// }
// impl<'a> ToByte for ConsumerMetadataRequest<'a> {
// fn encode<T: Write>(&self, buffer: &mut T) -> Result<()> {
// try_multi!(
// self.header.encode(buffer),
// self.group.encode(buffer)
// )
// }
// }
// // --------------------------------------------------------------------
// #[derive(Default, Debug)]
// pub struct ConsumerMetadataResponse {
// pub header: HeaderResponse,
// pub error: i16,
// pub id: i32,
// pub host: String,
// pub port: i32
// }
// impl FromByte for ConsumerMetadataResponse {
// type R = ConsumerMetadataResponse;
// #[allow(unused_must_use)]
// fn decode<T: Read>(&mut self, buffer: &mut T) -> Result<()> {
// try_multi!(
// self.header.decode(buffer),
// self.error.decode(buffer),
// self.id.decode(buffer),
// self.host.decode(buffer),
// self.port.decode(buffer)
// )
// }
// }
// --------------------------------------------------------------------
#[derive(Debug)]
pub struct OffsetFetchRequest<'a, 'b, 'c> {
pub header: HeaderRequest<'a>,
pub group: &'b str,
pub topic_partitions: Vec<TopicPartitionOffsetFetchRequest<'c>>
}
#[derive(Debug)]
pub struct TopicPartitionOffsetFetchRequest<'a> {
pub topic: &'a str,
pub partitions: Vec<PartitionOffsetFetchRequest>
}
#[derive(Debug)]
pub struct PartitionOffsetFetchRequest {
pub partition: i32
}
impl<'a, 'b, 'c> OffsetFetchRequest<'a, 'b, 'c> {
pub fn new(group: &'b str, correlation_id: i32, client_id: &'a str) -> OffsetFetchRequest<'a, 'b, 'c> {
OffsetFetchRequest {
header: HeaderRequest::new(
API_KEY_OFFSET_FETCH, API_VERSION, correlation_id, client_id),
group: group,
topic_partitions: vec!()
}
}
pub fn add(&mut self, topic: &'c str, partition: i32) {
for tp in &mut self.topic_partitions {
if tp.topic == topic {
tp.add(partition);
return;
}
}
let mut tp = TopicPartitionOffsetFetchRequest::new(topic);
tp.add(partition);
self.topic_partitions.push(tp);
}
}
impl<'a> TopicPartitionOffsetFetchRequest<'a> {
pub fn new(topic: &'a str) -> TopicPartitionOffsetFetchRequest<'a> {
TopicPartitionOffsetFetchRequest{topic: topic, partitions: vec!()}
}
pub fn add(&mut self, partition: i32) {
self.partitions.push(PartitionOffsetFetchRequest::new(partition));
}
}
impl PartitionOffsetFetchRequest {
pub fn new(partition: i32) -> PartitionOffsetFetchRequest {
PartitionOffsetFetchRequest{partition: partition}
}
}
impl<'a, 'b, 'c> ToByte for OffsetFetchRequest<'a, 'b, 'c> {
fn encode<W: Write>(&self, buffer: &mut W) -> Result<()> {
try_multi!(
self.header.encode(buffer),
self.group.encode(buffer),
self.topic_partitions.encode(buffer)
)
}
}
impl<'a> ToByte for TopicPartitionOffsetFetchRequest<'a> {
fn encode<W: Write>(&self, buffer: &mut W) -> Result<()> {
try_multi!(
self.topic.encode(buffer),
self.partitions.encode(buffer)
)
}
}
impl ToByte for PartitionOffsetFetchRequest {
fn encode<W: Write>(&self, buffer: &mut W) -> Result<()> {
self.partition.encode(buffer)
}
}
// --------------------------------------------------------------------
#[derive(Default, Debug)]
pub struct OffsetFetchResponse {
pub header: HeaderResponse,
pub topic_partitions: Vec<TopicPartitionOffsetFetchResponse>
}
#[derive(Default, Debug)]
pub struct TopicPartitionOffsetFetchResponse {
pub topic: String,
pub partitions: Vec<PartitionOffsetFetchResponse>
}
#[derive(Default, Debug)]
pub struct PartitionOffsetFetchResponse {
pub partition: i32,
pub offset: i64,
pub metadata: String,
pub error: i16
}
impl OffsetFetchResponse {
pub fn get_offsets(&self) -> Vec<TopicPartitionOffset> {
self.topic_partitions
.iter()
.flat_map(|ref tp| tp.get_offsets(tp.topic.clone()))
.collect()
}
}
impl TopicPartitionOffsetFetchResponse {
pub fn get_offsets(&self, topic: String) -> Vec<TopicPartitionOffset> {
self.partitions
.iter()
.map(|ref p| p.get_offsets(topic.clone()))
.collect()
}
}
impl PartitionOffsetFetchResponse {
pub fn get_offsets(&self, topic: String) -> TopicPartitionOffset {
TopicPartitionOffset {
topic: topic,
partition: self.partition,
offset: match Error::from_protocol_error(self.error) {
None => Ok(self.offset),
Some(e) => Err(e),
}
}
}
}
impl FromByte for OffsetFetchResponse {
type R = OffsetFetchResponse;
#[allow(unused_must_use)]
fn decode<T: Read>(&mut self, buffer: &mut T) -> Result<()> {
try_multi!(
self.header.decode(buffer),
self.topic_partitions.decode(buffer)
)
}
}
impl FromByte for TopicPartitionOffsetFetchResponse {
type R = TopicPartitionOffsetFetchResponse;
#[allow(unused_must_use)]
fn decode<T: Read>(&mut self, buffer: &mut T) -> Result<()> {
try_multi!(
self.topic.decode(buffer),
self.partitions.decode(buffer)
)
}
}
impl FromByte for PartitionOffsetFetchResponse {
type R = PartitionOffsetFetchResponse;
#[allow(unused_must_use)]
fn decode<T: Read>(&mut self, buffer: &mut T) -> Result<()> {
try_multi!(
self.partition.decode(buffer),
self.offset.decode(buffer),
self.metadata.decode(buffer),
self.error.decode(buffer)
)
}
}
// --------------------------------------------------------------------
#[derive(Debug)]
pub struct OffsetCommitRequest<'a, 'b> {
pub header: HeaderRequest<'a>,
pub group: &'b str,
pub topic_partitions: Vec<TopicPartitionOffsetCommitRequest<'b>>
}
#[derive(Debug)]
pub struct TopicPartitionOffsetCommitRequest<'a> {
pub topic: &'a str,
pub partitions: Vec<PartitionOffsetCommitRequest<'a>>
}
#[derive(Debug)]
pub struct PartitionOffsetCommitRequest<'a> {
pub partition: i32,
pub offset: i64,
pub metadata: &'a str,
}
impl<'a, 'b> OffsetCommitRequest<'a, 'b> {
pub fn new(group: &'b str, correlation_id: i32, client_id: &'a str) -> OffsetCommitRequest<'a, 'b> {
OffsetCommitRequest{
header: HeaderRequest::new(
API_KEY_OFFSET_COMMIT, API_VERSION, correlation_id, client_id),
group: group,
topic_partitions: vec!()
}
}
pub fn add(&mut self, topic: &'b str, partition: i32, offset: i64, metadata: &'b str) {
for tp in &mut self.topic_partitions {
if tp.topic == topic {
tp.add(partition, offset, metadata);
return;
}
}
let mut tp = TopicPartitionOffsetCommitRequest::new(topic);
tp.add(partition, offset, metadata);
self.topic_partitions.push(tp);
}
}
impl<'a> TopicPartitionOffsetCommitRequest<'a> {
pub fn new(topic: &'a str) -> TopicPartitionOffsetCommitRequest<'a> {
TopicPartitionOffsetCommitRequest {
topic: topic,
partitions: vec!()
}
}
pub fn add(&mut self, partition: i32, offset: i64, metadata: &'a str) {
self.partitions.push(PartitionOffsetCommitRequest::new(partition, offset, metadata))
}
}
impl<'a> PartitionOffsetCommitRequest<'a> {
pub fn new(partition: i32, offset: i64, metadata: &'a str) -> PartitionOffsetCommitRequest<'a> {
PartitionOffsetCommitRequest{
partition: partition,
offset: offset,
metadata: metadata
}
}
}
impl<'a, 'b> ToByte for OffsetCommitRequest<'a, 'b> {
fn encode<W: Write>(&self, buffer: &mut W) -> Result<()> {
try_multi!(
self.header.encode(buffer),
self.group.encode(buffer),
self.topic_partitions.encode(buffer)
)
}
}
impl<'a> ToByte for TopicPartitionOffsetCommitRequest<'a> {
fn encode<W: Write>(&self, buffer: &mut W) -> Result<()> {
try_multi!(
self.topic.encode(buffer),
self.partitions.encode(buffer)
)
}
}
impl<'a> ToByte for PartitionOffsetCommitRequest<'a> {
fn encode<W: Write>(&self, buffer: &mut W) -> Result<()> {
try_multi!(
self.partition.encode(buffer),
self.offset.encode(buffer),
self.metadata.encode(buffer)
)
}
}
// --------------------------------------------------------------------
#[derive(Default, Debug)]
pub struct OffsetCommitResponse {
pub header: HeaderResponse,
pub topic_partitions: Vec<TopicPartitionOffsetCommitResponse>
}
#[derive(Default, Debug)]
pub struct TopicPartitionOffsetCommitResponse {
pub topic: String,
pub partitions: Vec<PartitionOffsetCommitResponse>
}
#[derive(Default, Debug)]
pub struct PartitionOffsetCommitResponse {
pub partition: i32,
pub error: i16
}
impl FromByte for OffsetCommitResponse {
type R = OffsetCommitResponse;
#[allow(unused_must_use)]
fn decode<T: Read>(&mut self, buffer: &mut T) -> Result<()> {
try_multi!(
self.header.decode(buffer),
self.topic_partitions.decode(buffer)
)
}
}
impl FromByte for TopicPartitionOffsetCommitResponse {
type R = TopicPartitionOffsetCommitResponse;
#[allow(unused_must_use)]
fn decode<T: Read>(&mut self, buffer: &mut T) -> Result<()> {
try_multi!(
self.topic.decode(buffer),
self.partitions.decode(buffer)
)
}
}
impl FromByte for PartitionOffsetCommitResponse {
type R = PartitionOffsetCommitResponse;
#[allow(unused_must_use)]
fn decode<T: Read>(&mut self, buffer: &mut T) -> Result<()> {
try_multi!(
self.partition.decode(buffer),
self.error.decode(buffer)
)
}
}
|
pub enum CommsBackend {
Unix,
TCP,
TLS,
}
pub struct TcpClient {
pub host: String,
pub port: u16,
}
pub struct TlsFiles {
pub key: String,
pub cert: String,
pub ca: String,
}
pub struct Client {
pub backend: CommsBackend,
pub socket_path: Option<String>,
pub tcp_options: Option<TcpClient>,
pub use_tls: bool,
pub tls_files: Option<TlsFiles>,
}
impl Client {
pub fn new_unix(socket_path: String) -> Client {
Client {
backend: CommsBackend::Unix,
socket_path: Some(socket_path),
tcp_options: None,
use_tls: false,
tls_files: None,
}
}
pub fn new_tcp(tcp: TcpClient) -> Client {
Client {
backend: CommsBackend::TCP,
socket_path: None,
tcp_options: Some(tcp),
use_tls: false,
tls_files: None,
}
}
pub fn new_tls(tcp: TcpClient, tls_files: TlsFiles) -> Client {
Client {
backend: CommsBackend::TLS,
socket_path: None,
tcp_options: Some(tcp),
use_tls: true,
tls_files: Some(tls_files),
}
}
}
|
#[doc = "Reader of register DSI_PSR"]
pub type R = crate::R<u32, super::DSI_PSR>;
#[doc = "Reader of field `PD`"]
pub type PD_R = crate::R<bool, bool>;
#[doc = "Reader of field `PSSC`"]
pub type PSSC_R = crate::R<bool, bool>;
#[doc = "Reader of field `UANC`"]
pub type UANC_R = crate::R<bool, bool>;
#[doc = "Reader of field `PSS0`"]
pub type PSS0_R = crate::R<bool, bool>;
#[doc = "Reader of field `UAN0`"]
pub type UAN0_R = crate::R<bool, bool>;
#[doc = "Reader of field `RUE0`"]
pub type RUE0_R = crate::R<bool, bool>;
#[doc = "Reader of field `PSS1`"]
pub type PSS1_R = crate::R<bool, bool>;
#[doc = "Reader of field `UAN1`"]
pub type UAN1_R = crate::R<bool, bool>;
impl R {
#[doc = "Bit 1 - PHY Direction"]
#[inline(always)]
pub fn pd(&self) -> PD_R {
PD_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - PHY Stop State Clock lane"]
#[inline(always)]
pub fn pssc(&self) -> PSSC_R {
PSSC_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - ULPS Active Not Clock lane"]
#[inline(always)]
pub fn uanc(&self) -> UANC_R {
UANC_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - PHY Stop State lane 0"]
#[inline(always)]
pub fn pss0(&self) -> PSS0_R {
PSS0_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - ULPS Active Not lane 1"]
#[inline(always)]
pub fn uan0(&self) -> UAN0_R {
UAN0_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - RX ULPS Escape lane 0"]
#[inline(always)]
pub fn rue0(&self) -> RUE0_R {
RUE0_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 7 - PHY Stop State lane 1"]
#[inline(always)]
pub fn pss1(&self) -> PSS1_R {
PSS1_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 8 - ULPS Active Not lane 1"]
#[inline(always)]
pub fn uan1(&self) -> UAN1_R {
UAN1_R::new(((self.bits >> 8) & 0x01) != 0)
}
}
|
#[doc = "Reader of register CTRL"]
pub type R = crate::R<u8, super::CTRL>;
#[doc = "Writer for register CTRL"]
pub type W = crate::W<u8, super::CTRL>;
#[doc = "Register CTRL `reset()`'s with value 0"]
impl crate::ResetValue for super::CTRL {
type Type = u8;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `image`"]
pub type IMAGE_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `image`"]
pub struct IMAGE_W<'a> {
w: &'a mut W,
}
impl<'a> IMAGE_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0x03) | ((value as u8) & 0x03);
self.w
}
}
#[doc = "Reader of field `key`"]
pub type KEY_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `key`"]
pub struct KEY_W<'a> {
w: &'a mut W,
}
impl<'a> KEY_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x3f << 2)) | (((value as u8) & 0x3f) << 2);
self.w
}
}
impl R {
#[doc = "Bits 0:1 - Which image to reboot to. ``SB_WARMBOOT`` supports four images that are configured at FPGA startup. The bootloader is image 0, so set these bits to 0 to reboot back into the bootloader."]
#[inline(always)]
pub fn image(&self) -> IMAGE_R {
IMAGE_R::new((self.bits & 0x03) as u8)
}
#[doc = "Bits 2:7 - A reboot key used to prevent accidental reboots when writing to random areas of memory. To initiate a reboot, set this to ``0b101011``."]
#[inline(always)]
pub fn key(&self) -> KEY_R {
KEY_R::new(((self.bits >> 2) & 0x3f) as u8)
}
}
impl W {
#[doc = "Bits 0:1 - Which image to reboot to. ``SB_WARMBOOT`` supports four images that are configured at FPGA startup. The bootloader is image 0, so set these bits to 0 to reboot back into the bootloader."]
#[inline(always)]
pub fn image(&mut self) -> IMAGE_W {
IMAGE_W { w: self }
}
#[doc = "Bits 2:7 - A reboot key used to prevent accidental reboots when writing to random areas of memory. To initiate a reboot, set this to ``0b101011``."]
#[inline(always)]
pub fn key(&mut self) -> KEY_W {
KEY_W { w: self }
}
}
|
// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use {
element_management::{ElementManager, ElementManagerError, SimpleElementManager},
failure::{Error, ResultExt},
fidl_fuchsia_session::{
ElementManagerRequest, ElementManagerRequestStream, ProposeElementError,
},
fidl_fuchsia_session_examples::{ElementPingRequest, ElementPingRequestStream},
fidl_fuchsia_sys2 as fsys, fuchsia_async as fasync,
fuchsia_component::{client::connect_to_service, server::ServiceFs},
futures::{StreamExt, TryStreamExt},
rand::{distributions::Alphanumeric, thread_rng, Rng},
};
enum ExposedServices {
ElementManager(ElementManagerRequestStream),
ElementPing(ElementPingRequestStream),
}
// TODO(38577): Write example tests for the element session.
/// The child collection to add elements to. This must match a collection name declared in
/// this session's CML file.
const ELEMENT_COLLECTION_NAME: &str = "elements";
/// The maximum number of concurrent requests.
const NUM_CONCURRENT_REQUESTS: usize = 5;
/// This session exposes one service which is offered to all elements started in the session and
/// prints a string when an element sends a request to said service.
///
/// It also exposes the [`fidl_fuchsia_session.ElementManager`] service which an element proposer
/// can connect to in order to add an element to the session.
#[fasync::run_singlethreaded]
async fn main() -> Result<(), Error> {
let mut fs = ServiceFs::new_local();
fs.dir("svc").add_fidl_service(ExposedServices::ElementPing);
fs.dir("svc").add_fidl_service(ExposedServices::ElementManager);
fs.take_and_serve_directory_handle()?;
fs.for_each_concurrent(NUM_CONCURRENT_REQUESTS, move |service_request: ExposedServices| {
async move {
match service_request {
ExposedServices::ElementPing(request_stream) => {
handle_element_ping_requests(request_stream)
.await
.expect("Failed to run element ping service.");
}
ExposedServices::ElementManager(request_stream) => {
handle_element_manager_requests(request_stream)
.await
.expect("Failed to run element manager service.");
}
}
}
})
.await;
Ok(())
}
async fn handle_element_ping_requests(mut stream: ElementPingRequestStream) -> Result<(), Error> {
while let Some(ElementPingRequest::Ping { control_handle: _ }) =
stream.try_next().await.context("Error handling ping request stream")?
{
println!("Element did ping session.");
}
Ok(())
}
async fn handle_element_manager_requests(
mut stream: ElementManagerRequestStream,
) -> Result<(), Error> {
let realm =
connect_to_service::<fsys::RealmMarker>().context("Could not connect to Realm service.")?;
let element_manager = SimpleElementManager::new(realm);
while let Some(request) =
stream.try_next().await.context("Error handling element manager request stream")?
{
match request {
ElementManagerRequest::ProposeElement { spec, responder } => {
let mut child_name: String =
thread_rng().sample_iter(&Alphanumeric).take(16).collect();
child_name.make_ascii_lowercase();
let mut result = match element_manager
.add_element(spec, &child_name, ELEMENT_COLLECTION_NAME)
.await
{
// Most of the errors which could be encountered when adding an element are
// not the result of an error by the FIDL client. This lists all the cases
// explicitly, but it's up to each session to decide how to map the errors.
Ok(_) => Ok(()),
Err(ElementManagerError::UrlMissing { .. }) => {
Err(ProposeElementError::NotFound)
}
Err(ElementManagerError::NotCreated { .. }) => {
Err(ProposeElementError::Rejected)
}
Err(ElementManagerError::NotBound { .. }) => Err(ProposeElementError::Rejected),
};
let _ = responder.send(&mut result);
}
}
}
Ok(())
}
|
use std::{
error::Error,
fmt::{self, Display, Formatter},
};
use async_graphql::ParseRequestError;
use warp::{
http::{Response, StatusCode},
hyper::Body,
reject::Reject,
Reply,
};
/// Bad request error.
///
/// It's a wrapper of `async_graphql::ParseRequestError`. It is also a `Reply` -
/// by default it just returns a response containing the error message in plain
/// text.
#[derive(Debug)]
pub struct GraphQLBadRequest(pub ParseRequestError);
impl GraphQLBadRequest {
/// Get the appropriate status code of the error.
#[must_use]
pub fn status(&self) -> StatusCode {
match self.0 {
ParseRequestError::PayloadTooLarge => StatusCode::PAYLOAD_TOO_LARGE,
_ => StatusCode::BAD_REQUEST,
}
}
}
impl Display for GraphQLBadRequest {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}
impl Error for GraphQLBadRequest {
fn source(&self) -> Option<&(dyn Error + 'static)> {
Some(&self.0)
}
}
impl Reject for GraphQLBadRequest {}
impl Reply for GraphQLBadRequest {
fn into_response(self) -> Response<Body> {
Response::builder()
.status(self.status())
.body(Body::from(self.0.to_string()))
.unwrap()
}
}
impl From<ParseRequestError> for GraphQLBadRequest {
fn from(e: ParseRequestError) -> Self {
Self(e)
}
}
impl From<GraphQLBadRequest> for ParseRequestError {
fn from(e: GraphQLBadRequest) -> Self {
e.0
}
}
|
#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals, clashing_extern_declarations, clippy::all)]
#[link(name = "windows")]
extern "system" {}
pub type HidBooleanControl = *mut ::core::ffi::c_void;
pub type HidBooleanControlDescription = *mut ::core::ffi::c_void;
pub type HidCollection = *mut ::core::ffi::c_void;
#[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;
#[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
}
}
|
use scheme::errors::EvalErr;
use scheme::eval_expr;
use scheme::functions::Function;
use scheme::object::{Number, Object};
use scheme::scope::Scope;
use std::rc::Rc;
use std::time::Instant;
fn seq_sum(args: Vec<Rc<Object>>) -> Result<Rc<Object>, EvalErr> {
if args.len() > 1 {
return Err(EvalErr::TooManyArguments("seq_sum".to_string()));
}
let n = &args[0];
if let &Object::Number(Number::Integer(n)) = n.as_ref() {
let mut sum = 0;
for i in 0..=n {
sum += i;
}
Ok(Rc::new(Object::Number(Number::Integer(sum))))
} else {
Err(EvalErr::NumericArgsRequiredFor("seq_sum".to_string()))
}
}
/// Testing of different loops<br>
/// The target function calculates sum of numbers from 0 to N using regular recursion and tail recursion approach.<br>
/// N is chosen so that recursive version does not overflow its stack<br>
/// Native Rust realization of the function used as a reference<br>
#[rustfmt::skip]
fn benchmark_loops() {
const N: i32 = 500;
const LOOP: i32 = 200;
let test_fn = || -> i32 {
// (0..=N).sum() is slower
let mut sum = 0;
for i in 0..=N {
sum += i;
}
sum
};
let reference_sum: i32 = (0..=N).sum();
let start = Instant::now();
let scale = 1000;
for _ in 0..LOOP * scale {
assert_eq!(test_fn(), reference_sum);
}
let reference_time = start.elapsed().div_f64(scale as f64);
println!(" {:<20} {:12?}", "Rust loop", reference_time);
let scope = Rc::new(Scope::from_global());
scope.bind("seq-sum", Rc::new(Function::from_pointer(seq_sum)));
let scale = 100;
let start = Instant::now();
for _ in 0..LOOP * scale {
let sum = eval_expr(&format!("(seq-sum {})", N), &scope).unwrap();
assert_eq!(sum.to_string(), reference_sum.to_string());
}
let elapsed = start.elapsed().div_f64(scale as f64);
println!(" {:<20} {:12?} ({:.2 }x)",
"Rust implementation", elapsed, elapsed.as_secs_f64() / reference_time.as_secs_f64());
let scope = Rc::new(Scope::from_global());
let seq_sum = "
(define (seq-sum n)
(if (= 0 n) 0 (+ n (seq-sum (- n 1)))))";
eval_expr(seq_sum, &scope).unwrap();
let start = Instant::now();
for _ in 0..LOOP {
let sum = eval_expr(&format!("(seq-sum {})", N), &scope).unwrap();
assert_eq!(sum.to_string(), reference_sum.to_string());
}
let elapsed = start.elapsed();
println!(" {:<20} {:12?} ({:.0}x)",
"Recursion", elapsed, elapsed.as_secs_f64() / reference_time.as_secs_f64());
let scope = Rc::new(Scope::from_global());
let seq_sum = "
(define (seq-sum n)
(define (seq-sum n acc)
(if (= 0 n) acc (seq-sum (- n 1) (+ acc n))))
(seq-sum n 0))";
eval_expr(seq_sum, &scope).unwrap();
let start = Instant::now();
for _ in 0..LOOP {
let sum = eval_expr(&format!("(seq-sum {})", N), &scope).unwrap();
assert_eq!(sum.to_string(), reference_sum.to_string());
}
let elapsed = start.elapsed();
println!(" {:<20} {:12?} ({:.0}x)",
"Tail recursion", elapsed, elapsed.as_secs_f64() / reference_time.as_secs_f64());
}
/// ```
/// assert_eq!(arr_to_string(&[1, 2, 3, 4, 5]), "(1 2 3 4 5)");
/// ```
fn arr_to_string(arr: &[i32]) -> String {
let seq = (arr.iter())
.map(i32::to_string)
.collect::<Vec<_>>()
.join(" ");
format!("({})", seq)
}
/// Speed comparison of Rust zip+map, Scheme's built-in `map` function
/// and the same user-defined function `my-map` written in Scheme.
#[rustfmt::skip]
fn benchmark_map() {
const LOOP: i32 = 1000;
let arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
let mut arr2 = arr1.clone();
arr2.reverse();
let result = [9, 16, 21, 24, 25, 24, 21, 16, 9];
let test_fn = |arr1: &[i32], arr2: &[i32]| {
return (arr1.iter().zip(arr2))
.map(|(x, y)| x * y)
.collect::<Vec<_>>();
};
let start = Instant::now();
let scale = 1000;
for _ in 0..LOOP * scale {
let res = test_fn(&arr1, &arr2);
assert_eq!(res, result);
}
let reference_time = start.elapsed().div_f64(scale as f64);
println!(" {:<20} {:12?}", "Rust zip + map", reference_time);
let start = Instant::now();
let scope = Rc::new(Scope::from_global());
let map1 = format!("(map * '{} '{})", arr_to_string(&arr1), arr_to_string(&arr2));
let scale = 10;
for _ in 0..LOOP * scale {
let res = eval_expr(&map1, &scope).unwrap();
assert_eq!(res.to_string(), arr_to_string(&result));
}
let elapsed1 = start.elapsed().div_f64(scale as f64);
let x1 = elapsed1.as_secs_f64() / reference_time.as_secs_f64();
println!(" {:<20} {:12?} ({:.0}x)", "Built-in map", elapsed1, x1);
let my_map = "
(define (map1 func list)
(if (null? list)
'()
(cons (func (car list))
(map1 func (cdr list)))))
(define (my-map func . lists)
(if (null? (car lists))
'()
(cons (apply func (map1 car lists))
(apply my-map func (map1 cdr lists)))))";
let start = Instant::now();
let scope = Rc::new(Scope::from_global());
eval_expr(my_map, &scope).unwrap();
let map2 = format!("(my-map * '{} '{})", arr_to_string(&arr1), arr_to_string(&arr2));
for _ in 0..LOOP {
let res = eval_expr(&map2, &scope).unwrap();
assert_eq!(res.to_string(), arr_to_string(&result));
}
let elapsed2 = start.elapsed();
let x2 = elapsed2.as_secs_f64() / elapsed1.as_secs_f64();
println!(" {:<20} {:12?} ({:.0}x * {:.0}x)", "Scheme map", elapsed2, x1, x2);
}
/// Counting number of primes in range 2..N in the simplest way.
#[rustfmt::skip]
fn behchmark_primes() {
const N : i64 = 10_000;
let test_fn = |n| {
let mut acc = 0;
for x in 2..n {
for y in 2.. {
if y * y > x {
acc += 1;
break;
}
if x % y == 0 {
break;
}
}
}
acc
};
let start = Instant::now();
let scale = 1000;
let result = test_fn(N);
for _ in 0..scale {
let res = test_fn(N);
assert_eq!(res, result);
}
let reference_time = start.elapsed().div_f64(scale as f64);
println!(" {:<20} {:12?}", "Rust impl", reference_time);
let count_primes = "
(define (prime? x y)
(cond
((> (* y y) x) #t)
((= (modulo x y) 0) #f)
(else (prime? x (+ y 1)))))
(define (count-primes-acc n acc)
(if (= n 1)
acc
(if (prime? n 2)
(count-primes-acc (- n 1) (+ acc 1))
(count-primes-acc (- n 1) acc))))
(define (count-primes n)
(count-primes-acc n 0))";
let start = Instant::now();
let scope = Rc::new(Scope::from_global());
eval_expr(count_primes, &scope).unwrap();
let scm_code: String = format!("(count-primes {})", N);
{
let res = eval_expr(&scm_code, &scope).unwrap();
assert_eq!(res.to_string(), result.to_string());
}
let elapsed1 = start.elapsed();
let x1 = elapsed1.as_secs_f64() / reference_time.as_secs_f64();
println!(" {:<20} {:12?} ({:.0}x)", "Scheme impl", elapsed1, x1);
}
#[test]
fn run_bench() {
println!("{:=^50}", "[ Loop benchmark ]");
benchmark_loops();
println!();
println!("{:=^50}", "[ Map benchmark ]");
benchmark_map();
println!();
println!("{:=^50}", "[ Count primes benchmark ]");
behchmark_primes();
println!();
}
|
pub enum Format {
Text,
JSON
}
impl Format {
pub fn from_string(f: String) -> Format {
if f.trim().to_lowercase() == "json" {
return Format::JSON;
}
Format::Text
}
} |
pub mod image;
pub use self::image::Image;
use crate::{
geo::{
collection::{BezierRotate, Mesh, Plane, Sphere},
Geo,
},
scene::{Camera, Renderer, World},
Flt,
};
use pbr::ProgressBar;
use serde::de::DeserializeOwned;
use serde_json::Value;
use std::collections::HashMap;
use std::fs;
use std::thread;
pub fn clamp(x: Flt) -> Flt {
if x < 0.0 {
0.0
} else {
if x > 1.0 {
1.0
} else {
x
}
}
}
pub fn to_byte(x: Flt) -> u8 {
(clamp(x).powf(1.0 / 2.2) * 255.0 + 0.5) as u8
}
pub struct Rng {
pub seed: u32,
}
const INV32: Flt = 1.0 / std::u32::MAX as Flt;
impl Rng {
pub fn new(seed: u32) -> Self {
Self { seed: if seed == 0 { 233 } else { seed } }
}
pub fn gen(&mut self) -> Flt {
let mut x = self.seed;
x ^= x << 13;
x ^= x >> 17;
x ^= x << 5;
self.seed = x;
x as Flt * INV32
}
}
pub type FromJsonFunc = fn(Value) -> Box<dyn Geo>;
pub fn new_from_json<T: Geo + DeserializeOwned + 'static>(v: Value) -> Box<dyn Geo> {
let obj = serde_json::from_value::<T>(v).expect("Invalid Value");
Box::new(obj)
}
pub fn from_json(path: &str, custom: HashMap<String, FromJsonFunc>) -> (World, Image, String) {
let data = fs::read_to_string(path).expect(&format!("Unable to read {}", path));
let mut data: Value = serde_json::from_str(&data).expect("Cannot convert to json");
let path: String = serde_json::from_value(data["path"].take()).expect("Invalid path");
let w: usize = serde_json::from_value(data["width"].take()).expect("Invalid width");
let h: usize = serde_json::from_value(data["height"].take()).expect("Invalid height");
let p = Image::new(w, h);
let camera: Camera = serde_json::from_value(data["camera"].take()).expect("Invalid camera");
let max_depth: usize =
serde_json::from_value(data["max_depth"].take()).expect("Invalid maximum depth");
let thread_num: usize =
serde_json::from_value(data["thread_num"].take()).expect("Invalid thread number");
let stack_size: usize =
serde_json::from_value(data["stack_size"].take()).expect("Invalid stack size");
let na: Flt = serde_json::from_value(data["Na"].take()).expect("Invalid Na");
let ng: Flt = serde_json::from_value(data["Ng"].take()).expect("Invalid Ng");
let renderer: Renderer =
serde_json::from_value(data["renderer"].take()).expect("Invalid renderer");
let mut w = World::new(camera, max_depth, thread_num, stack_size, na, ng, renderer);
match data["objects"].take() {
Value::Array(objs) => thread::Builder::new()
.stack_size(stack_size)
.spawn(move || {
println!("Loading objects...");
let mut pb = ProgressBar::new(objs.len() as u64);
objs.into_iter().for_each(|_obj| {
let mut obj = _obj;
match obj["type"].take() {
Value::String(tp) => match tp.as_ref() {
"sphere" => w.add(new_from_json::<Sphere>(obj)),
"plane" => w.add(new_from_json::<Plane>(obj)),
"mesh" => w.add(new_from_json::<Mesh>(obj)),
"bezier_rotate" => w.add(new_from_json::<BezierRotate>(obj)),
_ => {
if let Some(f) = custom.get(&tp) {
w.add(f(obj));
return;
}
panic!("Unknown obj");
}
},
_ => panic!("Invalid obj"),
};
pb.inc();
});
pb.finish_println("...loaded\n");
(w, p, path)
})
.unwrap()
.join()
.unwrap(),
_ => panic!("objs is not an array"),
}
}
|
// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT
#[cfg(any(feature = "v2_16", feature = "dox"))]
use glib;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::GString;
use glib::StaticType;
use glib::Value;
use glib_sys;
use gobject_sys;
use libc;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;
#[cfg(any(feature = "v2_16", feature = "dox"))]
use std::ptr;
use webkit2_webextension_sys;
use DOMObject;
glib_wrapper! {
pub struct DOMDOMTokenList(Object<webkit2_webextension_sys::WebKitDOMDOMTokenList, webkit2_webextension_sys::WebKitDOMDOMTokenListClass, DOMDOMTokenListClass>) @extends DOMObject;
match fn {
get_type => || webkit2_webextension_sys::webkit_dom_dom_token_list_get_type(),
}
}
pub const NONE_DOMDOM_TOKEN_LIST: Option<&DOMDOMTokenList> = None;
pub trait DOMDOMTokenListExt: 'static {
//#[cfg_attr(feature = "v2_22", deprecated)]
//#[cfg(any(feature = "v2_16", feature = "dox"))]
//fn add(&self, error: &mut glib::Error, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);
#[cfg_attr(feature = "v2_22", deprecated)]
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn contains(&self, token: &str) -> bool;
#[cfg_attr(feature = "v2_22", deprecated)]
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn get_length(&self) -> libc::c_ulong;
#[cfg_attr(feature = "v2_22", deprecated)]
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn get_value(&self) -> Option<GString>;
#[cfg_attr(feature = "v2_22", deprecated)]
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn item(&self, index: libc::c_ulong) -> Option<GString>;
//#[cfg_attr(feature = "v2_22", deprecated)]
//#[cfg(any(feature = "v2_16", feature = "dox"))]
//fn remove(&self, error: &mut glib::Error, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);
#[cfg_attr(feature = "v2_22", deprecated)]
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn replace(&self, token: &str, newToken: &str) -> Result<(), glib::Error>;
#[cfg_attr(feature = "v2_22", deprecated)]
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn set_value(&self, value: &str);
#[cfg_attr(feature = "v2_22", deprecated)]
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn toggle(&self, token: &str, force: bool) -> Result<(), glib::Error>;
fn get_property_length(&self) -> libc::c_ulong;
fn get_property_value(&self) -> Option<GString>;
fn set_property_value(&self, value: Option<&str>);
fn connect_property_length_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_property_value_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}
impl<O: IsA<DOMDOMTokenList>> DOMDOMTokenListExt for O {
//#[cfg(any(feature = "v2_16", feature = "dox"))]
//fn add(&self, error: &mut glib::Error, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
// unsafe { TODO: call webkit2_webextension_sys:webkit_dom_dom_token_list_add() }
//}
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn contains(&self, token: &str) -> bool {
unsafe {
from_glib(
webkit2_webextension_sys::webkit_dom_dom_token_list_contains(
self.as_ref().to_glib_none().0,
token.to_glib_none().0,
),
)
}
}
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn get_length(&self) -> libc::c_ulong {
unsafe {
webkit2_webextension_sys::webkit_dom_dom_token_list_get_length(
self.as_ref().to_glib_none().0,
)
}
}
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn get_value(&self) -> Option<GString> {
unsafe {
from_glib_full(
webkit2_webextension_sys::webkit_dom_dom_token_list_get_value(
self.as_ref().to_glib_none().0,
),
)
}
}
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn item(&self, index: libc::c_ulong) -> Option<GString> {
unsafe {
from_glib_full(webkit2_webextension_sys::webkit_dom_dom_token_list_item(
self.as_ref().to_glib_none().0,
index,
))
}
}
//#[cfg(any(feature = "v2_16", feature = "dox"))]
//fn remove(&self, error: &mut glib::Error, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
// unsafe { TODO: call webkit2_webextension_sys:webkit_dom_dom_token_list_remove() }
//}
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn replace(&self, token: &str, newToken: &str) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = webkit2_webextension_sys::webkit_dom_dom_token_list_replace(
self.as_ref().to_glib_none().0,
token.to_glib_none().0,
newToken.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn set_value(&self, value: &str) {
unsafe {
webkit2_webextension_sys::webkit_dom_dom_token_list_set_value(
self.as_ref().to_glib_none().0,
value.to_glib_none().0,
);
}
}
#[cfg(any(feature = "v2_16", feature = "dox"))]
fn toggle(&self, token: &str, force: bool) -> Result<(), glib::Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = webkit2_webextension_sys::webkit_dom_dom_token_list_toggle(
self.as_ref().to_glib_none().0,
token.to_glib_none().0,
force.to_glib(),
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
fn get_property_length(&self) -> libc::c_ulong {
unsafe {
let mut value = Value::from_type(<libc::c_ulong as StaticType>::static_type());
gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"length\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value
.get()
.expect("Return Value for property `length` getter")
.unwrap()
}
}
fn get_property_value(&self) -> Option<GString> {
unsafe {
let mut value = Value::from_type(<GString as StaticType>::static_type());
gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"value\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value
.get()
.expect("Return Value for property `value` getter")
}
}
fn set_property_value(&self, value: Option<&str>) {
unsafe {
gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"value\0".as_ptr() as *const _,
Value::from(value).to_glib_none().0,
);
}
}
fn connect_property_length_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_length_trampoline<P, F: Fn(&P) + 'static>(
this: *mut webkit2_webextension_sys::WebKitDOMDOMTokenList,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<DOMDOMTokenList>,
{
let f: &F = &*(f as *const F);
f(&DOMDOMTokenList::from_glib_borrow(this).unsafe_cast())
}
unsafe {
let f: Box_<F> = Box_::new(f);
connect_raw(
self.as_ptr() as *mut _,
b"notify::length\0".as_ptr() as *const _,
Some(transmute(notify_length_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
}
}
fn connect_property_value_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_value_trampoline<P, F: Fn(&P) + 'static>(
this: *mut webkit2_webextension_sys::WebKitDOMDOMTokenList,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<DOMDOMTokenList>,
{
let f: &F = &*(f as *const F);
f(&DOMDOMTokenList::from_glib_borrow(this).unsafe_cast())
}
unsafe {
let f: Box_<F> = Box_::new(f);
connect_raw(
self.as_ptr() as *mut _,
b"notify::value\0".as_ptr() as *const _,
Some(transmute(notify_value_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
}
}
}
impl fmt::Display for DOMDOMTokenList {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "DOMDOMTokenList")
}
}
|
//! DAG-Protobuf codec.
use crate::ipld::{BlockError, Ipld, IpldError};
use cid::Cid;
use std::{
collections::BTreeMap,
convert::{TryFrom, TryInto},
};
use thiserror::Error;
/// Protobuf codec.
#[derive(Clone, Debug, Hash, PartialEq, Eq)]
pub struct DagPbCodec;
impl DagPbCodec {
pub fn encode(ipld: &Ipld) -> Result<Box<[u8]>, ProtobufError> {
let pb_node: PbNode = ipld.try_into()?;
Ok(pb_node.into_bytes())
}
pub fn decode(data: &[u8]) -> Result<Ipld, ProtobufError> {
Ok(PbNode::from_bytes(data)?.into())
}
}
/// Protobuf error.
#[derive(Debug, Error)]
pub enum ProtobufError {
#[error("{0}")]
Prost(#[from] prost::DecodeError),
#[error("{0}")]
Cid(#[from] cid::Error),
#[error("{0}")]
Ipld(#[from] IpldError),
}
impl From<ProtobufError> for BlockError {
fn from(error: ProtobufError) -> Self {
Self::CodecError(error.into())
}
}
mod pb {
include!(concat!(env!("OUT_DIR"), "/dag_pb.rs"));
}
pub struct PbLink {
pub cid: Cid,
pub name: String,
pub size: u64,
}
pub struct PbNode {
pub links: Vec<PbLink>,
pub data: Vec<u8>,
}
use prost::Message;
impl PbNode {
pub fn from_bytes(bytes: &[u8]) -> Result<Self, ProtobufError> {
let proto: pb::PbNode = pb::PbNode::decode(bytes)?;
let data = proto.data;
let mut links = Vec::new();
for link in proto.links {
let cid = Cid::try_from(link.hash)?;
let name = link.name;
let size = link.tsize;
links.push(PbLink { cid, name, size });
}
Ok(PbNode { links, data })
}
pub fn into_bytes(self) -> Box<[u8]> {
let links = self
.links
.into_iter()
.map(|link| pb::PbLink {
hash: link.cid.to_bytes(),
name: link.name,
tsize: link.size,
})
.collect::<Vec<_>>();
let proto = pb::PbNode {
data: self.data,
links,
};
let mut res = Vec::with_capacity(proto.encoded_len());
proto
.encode(&mut res)
.expect("there is no situation in which the protobuf message can be invalid");
res.into_boxed_slice()
}
}
impl From<PbNode> for Ipld {
fn from(val: PbNode) -> Self {
let mut map = BTreeMap::<String, Ipld>::new();
let links = val
.links
.into_iter()
.map(|link| link.into())
.collect::<Vec<Ipld>>();
map.insert("Links".to_string(), links.into());
map.insert("Data".to_string(), val.data.into());
map.into()
}
}
impl From<PbLink> for Ipld {
fn from(val: PbLink) -> Self {
let mut map = BTreeMap::<String, Ipld>::new();
map.insert("Hash".to_string(), val.cid.into());
map.insert("Name".to_string(), val.name.into());
map.insert("Tsize".to_string(), val.size.into());
map.into()
}
}
impl TryFrom<&Ipld> for PbNode {
type Error = IpldError;
fn try_from(ipld: &Ipld) -> Result<PbNode, Self::Error> {
let links = if let Ipld::List(links) = ipld.get("Links").ok_or(IpldError::KeyNotFound)? {
links
.iter()
.map(|link| link.try_into())
.collect::<Result<_, _>>()?
} else {
return Err(IpldError::NotList);
};
let data = if let Ipld::Bytes(data) = ipld.get("Data").ok_or(IpldError::KeyNotFound)? {
data.clone()
} else {
return Err(IpldError::NotBytes);
};
Ok(PbNode { links, data })
}
}
impl TryFrom<&Ipld> for PbLink {
type Error = IpldError;
fn try_from(ipld: &Ipld) -> Result<PbLink, Self::Error> {
let cid = if let Ipld::Link(cid) = ipld.get("Hash").ok_or(IpldError::KeyNotFound)? {
cid.clone()
} else {
return Err(IpldError::NotLink);
};
let name = if let Ipld::String(name) = ipld.get("Name").ok_or(IpldError::KeyNotFound)? {
name.clone()
} else {
return Err(IpldError::NotString);
};
let size = if let Ipld::Integer(size) = ipld.get("Tsize").ok_or(IpldError::KeyNotFound)? {
*size as u64
} else {
return Err(IpldError::NotInteger);
};
Ok(PbLink { cid, name, size })
}
}
|
#[cfg(feature = "stm32f4xx-hal")]
use stm32f4xx_hal::{
bb,
gpio::{
gpioa::{PA1, PA2, PA7},
gpiob::{PB11, PB12, PB13},
gpioc::{PC1, PC4, PC5},
gpiog::{PG11, PG13, PG14},
Floating, Input,
Speed::VeryHigh,
},
stm32::{RCC, SYSCFG},
};
#[cfg(feature = "stm32f7xx-hal")]
use cortex_m::interrupt;
#[cfg(feature = "stm32f7xx-hal")]
use stm32f7xx_hal::{
pac::{RCC, SYSCFG},
gpio::{
gpioa::{PA1, PA2, PA7},
gpiob::{PB11, PB12, PB13},
gpioc::{PC1, PC4, PC5},
gpiog::{PG11, PG13, PG14},
Floating, Input,
Speed::VeryHigh,
},
};
// Enable syscfg and ethernet clocks. Reset the Ethernet MAC.
pub(crate) fn setup() {
#[cfg(feature = "stm32f4xx-hal")]
unsafe {
const SYSCFG_BIT: u8 = 14;
const ETH_MAC_BIT: u8 = 25;
const ETH_TX_BIT: u8 = 26;
const ETH_RX_BIT: u8 = 27;
const MII_RMII_BIT: u8 = 23;
//NOTE(unsafe) This will only be used for atomic writes with no side-effects
let rcc = &*RCC::ptr();
let syscfg = &*SYSCFG::ptr();
// Enable syscfg clock
bb::set(&rcc.apb2enr, SYSCFG_BIT);
if rcc.ahb1enr.read().ethmacen().bit_is_set() {
// pmc must be changed with the ethernet controller disabled or under reset
bb::clear(&rcc.ahb1enr, ETH_MAC_BIT);
}
// select MII or RMII mode
// 0 = MII, 1 = RMII
bb::set(&syscfg.pmc, MII_RMII_BIT);
// enable ethernet clocks
bb::set(&rcc.ahb1enr, ETH_MAC_BIT);
bb::set(&rcc.ahb1enr, ETH_TX_BIT);
bb::set(&rcc.ahb1enr, ETH_RX_BIT);
// reset pulse
bb::set(&rcc.ahb1rstr, ETH_MAC_BIT);
bb::clear(&rcc.ahb1rstr, ETH_MAC_BIT);
}
#[cfg(feature = "stm32f7xx-hal")]
//stm32f7xx-hal does not currently have bitbanding
interrupt::free(|_| unsafe {
//NOTE(unsafe) Interrupt free and we only modify mac bits
let rcc = &*RCC::ptr();
let syscfg = &*SYSCFG::ptr();
// enable syscfg clock
rcc.apb2enr.modify(|_, w| w.syscfgen().set_bit());
if rcc.ahb1enr.read().ethmacen().bit_is_set() {
// pmc must be changed with the ethernet controller disabled or under reset
rcc.ahb1enr.modify(|_, w| w.ethmacen().clear_bit());
}
// select MII or RMII mode
// 0 = MII, 1 = RMII
syscfg.pmc.modify(|_, w| w.mii_rmii_sel().set_bit());
// enable ethernet clocks
rcc.ahb1enr.modify(|_, w| {
w.ethmacen()
.set_bit()
.ethmactxen()
.set_bit()
.ethmacrxen()
.set_bit()
});
//reset pulse
rcc.ahb1rstr.modify(|_, w| w.ethmacrst().set_bit());
rcc.ahb1rstr.modify(|_, w| w.ethmacrst().clear_bit());
});
}
/// RMII Reference Clock.
pub unsafe trait RmiiRefClk {}
/// RMII MDIO.
pub unsafe trait MDIO {}
/// RMII MDC.
pub unsafe trait MDC {}
/// RMII RX Data Valid.
pub unsafe trait RmiiCrsDv {}
/// RMII TX Enable.
pub unsafe trait RmiiTxEN {}
/// RMII TXD0.
pub unsafe trait RmiiTxD0 {}
/// RMII TXD1.
pub unsafe trait RmiiTxD1 {}
/// RMII RXD0.
pub unsafe trait RmiiRxD0 {}
/// RMII RXD1.
pub unsafe trait RmiiRxD1 {}
/// Trait needed to setup the pins for the Ethernet peripheral.
pub trait AlternateVeryHighSpeed {
/// Puts the pin in the Alternate Function 11 with Very High Speed.
fn into_af11_very_high_speed(self);
}
pub struct EthPins<REFCLK, IO, CLK, CRS, TXEN, TXD0, TXD1, RXD0, RXD1> {
pub ref_clk: REFCLK,
pub md_io: IO,
pub md_clk: CLK,
pub crs: CRS,
pub tx_en: TXEN,
pub tx_d0: TXD0,
pub tx_d1: TXD1,
pub rx_d0: RXD0,
pub rx_d1: RXD1,
}
impl<REFCLK, IO, CLK, CRS, TXEN, TXD0, TXD1, RXD0, RXD1>
EthPins<REFCLK, IO, CLK, CRS, TXEN, TXD0, TXD1, RXD0, RXD1>
where
REFCLK: RmiiRefClk + AlternateVeryHighSpeed,
IO: MDIO + AlternateVeryHighSpeed,
CLK: MDC + AlternateVeryHighSpeed,
CRS: RmiiCrsDv + AlternateVeryHighSpeed,
TXEN: RmiiTxEN + AlternateVeryHighSpeed,
TXD0: RmiiTxD0 + AlternateVeryHighSpeed,
TXD1: RmiiTxD1 + AlternateVeryHighSpeed,
RXD0: RmiiRxD0 + AlternateVeryHighSpeed,
RXD1: RmiiRxD1 + AlternateVeryHighSpeed,
{
/// Pin setup.
///
/// Set RMII pins to
/// * Alternate function 11
/// * High-speed
///
/// This function consumes the pins so that you cannot use them
/// anywhere else by accident.
pub fn setup_pins(self) {
self.ref_clk.into_af11_very_high_speed();
self.md_io.into_af11_very_high_speed();
self.md_clk.into_af11_very_high_speed();
self.crs.into_af11_very_high_speed();
self.tx_en.into_af11_very_high_speed();
self.tx_d0.into_af11_very_high_speed();
self.tx_d1.into_af11_very_high_speed();
self.rx_d0.into_af11_very_high_speed();
self.rx_d1.into_af11_very_high_speed();
}
}
macro_rules! impl_pins {
( $($traity:ident: [$($pin:ty,)+],)+ ) => {
$(
$(
unsafe impl $traity for $pin {}
impl AlternateVeryHighSpeed for $pin {
fn into_af11_very_high_speed(self) {
self.into_alternate_af11().set_speed(VeryHigh);
}
}
)+
)+
};
}
#[cfg(feature = "device-selected")]
impl_pins!(
RmiiRefClk: [
PA1<Input<Floating>>,
],
MDIO: [
PA2<Input<Floating>>,
],
MDC: [
PC1<Input<Floating>>,
],
RmiiCrsDv: [
PA7<Input<Floating>>,
],
RmiiTxEN: [
PB11<Input<Floating>>,
PG11<Input<Floating>>,
],
RmiiTxD0: [
PB12<Input<Floating>>,
PG13<Input<Floating>>,
],
RmiiTxD1: [
PB13<Input<Floating>>,
PG14<Input<Floating>>,
],
RmiiRxD0: [
PC4<Input<Floating>>,
],
RmiiRxD1: [
PC5<Input<Floating>>,
],
);
|
use std::collections::LinkedList; //std library: linkedlist allows vector Command modifiction
use piston_window::{Context, G2d}; //graph buffer
use piston_window::types::Color; //color
use crate::shapes1:: {make_shape};
const SNAKE_COLOR: Color = [0.0, 0.0, 1.0, 1.0]; //making the color of the snake [red, green, blue, opasity]
#[derive(Copy, Clone, PartialEq)]
pub enum Command { //Defining directions
Up,
Down,
Left,
Right,
}
impl Command { //impl == Defning method for the correspindin commands, and direction ,
pub fn opposite(&self) -> Command { //Counter reverse not allowed class
match *self {
Command::Up => Command::Down, //while going up cant go down... by passing back down
Command::Down => Command::Up, //wiseversa
Command::Left => Command::Right, //going left, cant go right...by passing back right
Command::Right => Command::Left, //wiseversa
}
}
}
#[derive(Debug, Clone)] //struct for block type
struct Block {
x: i32,
y: i32,
}
pub struct Snake {
command: Command, //takes in command from Command
S_body: LinkedList<Block>, //Define the S_body and set of blocks
tail: Option<Block>, //mutable, ever changing
}
impl Snake { //implementing the snake
pub fn new(x: i32, y: i32) -> Snake { //Method of coord for snake
let mut S_body: LinkedList<Block> = LinkedList::new(); //mutable S_body (changing )
S_body.push_back(Block { //Push_back , appends an element to the back of the list
x: x + 2, //Default snake with length of 3
y,
});
S_body.push_back(Block {
x: x + 1,
y, //second being x+1
});
S_body.push_back(Block {
x, //first default ebing x&y
y,
}); //resulting in a horizontal snake
Snake {
command: Command::Right, //by default moving to the right
S_body,
tail: None, //default lenght (3blocks)
}
}
pub fn make(&self, con: &Context, g: &mut G2d) {
for block in &self.S_body {
make_shape(SNAKE_COLOR, block.x, block.y, con, g); //each block witch contains the snake
}
}
pub fn head_position(&self) -> (i32, i32) { //Defning head (where move leading is)
let head_block = self.S_body.front().unwrap(); //head_block, referring to the first element , unwrap gets rid of enum without error
(head_block.x, head_block.y)
}
pub fn move_forward(&mut self, dir: Option<Command>) { //multable snake moving forward with commands
match dir {
Some(d) => self.command = d,
None => (),
}
let (last_x, last_y): (i32, i32) = self.head_position(); // defning the posttion of head
let new_block = match self.command { // Defnifng movement in block terms
Command::Up => Block {
x: last_x,
y: last_y - 1, // given the down is + y axis while up is -
},
Command::Down => Block {
x: last_x,
y: last_y + 1,
},
Command::Left => Block {
x: last_x - 1,
y: last_y,
},
Command::Right => Block {
x: last_x + 1,
y: last_y,
},
};
self.S_body.push_front(new_block); //snake move, rf the last block and add a new block to the front.
let removed_block = self.S_body.pop_back().unwrap(); //pop back the linkedlist
self.tail = Some(removed_block); //removed from the end
}
pub fn head_Command(&self) -> Command { // method for getting the head position
self.command
}
pub fn next_head(&self, dir: Option<Command>) -> (i32, i32) { //getting headposition
let (head_x, head_y): (i32, i32) = self.head_position();
let mut moving_dir = self.command; //mutable moving firection from the command
match dir { //applying the command given
Some(d) => moving_dir = d,
None => {}
}
match moving_dir { //Rescenter and accuracy
Command::Up => (head_x, head_y - 1),
Command::Down => (head_x, head_y + 1),
Command::Left => (head_x - 1, head_y),
Command::Right => (head_x + 1, head_y),
}
}
//grow snake
pub fn restore_tail(&mut self) { // getting big similar method as tail but will do if apple is intercepted
let blk = self.tail.clone().unwrap();
self.S_body.push_back(blk);
}
//lose condition
pub fn overlap_tail(&self, x: i32, y: i32) -> bool {
let mut ch = 0;
for block in &self.S_body {
if x == block.x && y == block.y { //if overlaps with s_body
return true;
}
ch += 1;
if ch == self.S_body.len() - 1 { // checking for so that the head and tail interception dont cause losing condition, so
// len-1 ignoring 1 block where the head and tail momentarily overlap
break;
}
}
return false;
}
} |
use crate::{field::Field, Record};
/// Iterator over fields of a record.
#[derive(Debug, Clone)]
pub struct Fields<'a> {
record: &'a Record<'a>,
offset: usize,
}
impl<'a> Fields<'a> {
#[doc(hidden)]
pub fn new(record: &'a Record<'a>) -> Fields<'a> {
Fields { record, offset: 0 }
}
}
impl<'a> Iterator for Fields<'a> {
type Item = Field<'a>;
fn next(&mut self) -> Option<Field<'a>> {
let i = self.offset;
self.offset += 1;
self.record.directory.entries.get(i).map(|entry| {
let offset = self.record.data_offset + entry.2;
Field::new(entry.0, &self.record.data[offset..offset + entry.1 - 1])
})
}
fn size_hint(&self) -> (usize, Option<usize>) {
let bound = self.record.directory.entries.len() - self.offset;
(bound, Some(bound))
}
}
|
mod test_utils;
mod server_decode {
use super::test_utils::TestIO;
use async_std::io::prelude::*;
use http_types::headers::TRANSFER_ENCODING;
use http_types::Request;
use http_types::Result;
use http_types::Url;
use pretty_assertions::assert_eq;
async fn decode_lines(lines: Vec<&str>) -> Result<Option<Request>> {
let s = lines.join("\r\n");
let (mut client, server) = TestIO::new();
client.write_all(s.as_bytes()).await?;
client.close();
async_h1::server::decode(server)
.await
.map(|r| r.map(|(r, _)| r))
}
#[async_std::test]
async fn post_with_body() -> Result<()> {
let mut request = decode_lines(vec![
"POST / HTTP/1.1",
"host: localhost:8080",
"content-length: 5",
"content-type: text/plain;charset=utf-8",
"another-header: header value",
"another-header: other header value",
"",
"hello",
"",
])
.await?
.unwrap();
assert_eq!(request.method(), http_types::Method::Post);
assert_eq!(request.body_string().await?, "hello");
assert_eq!(request.content_type(), Some(http_types::mime::PLAIN));
assert_eq!(request.version(), Some(http_types::Version::Http1_1));
assert_eq!(request.host(), Some("localhost:8080"));
assert_eq!(
request.url(),
&Url::parse("http://localhost:8080/").unwrap()
);
let custom_header = request.header("another-header").unwrap();
assert_eq!(custom_header[0], "header value");
assert_eq!(custom_header[1], "other header value");
Ok(())
}
#[async_std::test]
async fn chunked() -> Result<()> {
let mut request = decode_lines(vec![
"POST / HTTP/1.1",
"host: localhost:8080",
"transfer-encoding: chunked",
"content-type: text/plain;charset=utf-8",
"",
"1",
"h",
"1",
"e",
"3",
"llo",
"0",
"",
])
.await?
.unwrap();
assert_eq!(request[TRANSFER_ENCODING], "chunked");
assert_eq!(request.body_string().await?, "hello");
Ok(())
}
#[ignore = r#"
the test previously did not actually assert the correct thing prevously
and the behavior does not yet work as intended
"#]
#[async_std::test]
async fn invalid_trailer() -> Result<()> {
let mut request = decode_lines(vec![
"GET / HTTP/1.1",
"host: domain.com",
"content-type: application/octet-stream",
"transfer-encoding: chunked",
"trailer: x-invalid",
"",
"0",
"x-invalid: å",
"",
])
.await?
.unwrap();
assert!(request.body_string().await.is_err());
Ok(())
}
#[async_std::test]
async fn unexpected_eof() -> Result<()> {
let mut request = decode_lines(vec![
"POST / HTTP/1.1",
"host: example.com",
"content-type: text/plain",
"content-length: 11",
"",
"not 11",
])
.await?
.unwrap();
let mut string = String::new();
// we use read_to_string because although not currently the
// case, at some point soon body_string will error if the
// retrieved content length is not the same as the header (if
// the client disconnects)
request.read_to_string(&mut string).await?;
assert_eq!(string, "not 11");
Ok(())
}
}
|
use crate::runtime::time::datetime;
use liblumen_alloc::erts::process::Process;
use liblumen_alloc::erts::term::prelude::*;
#[native_implemented::function(erlang:date/0)]
pub fn result(process: &Process) -> Term {
let date: [usize; 3] = datetime::local_date();
process.tuple_from_slice(&[
process.integer(date[0]),
process.integer(date[1]),
process.integer(date[2]),
])
}
|
//! Core definitions module.
use std::{collections::BTreeMap, convert::TryInto};
use anyhow::anyhow;
use thiserror::Error;
pub use oasis_core_keymanager_api_common::KeyManagerError;
use crate::{
callformat,
context::{BatchContext, Context, TxContext},
dispatcher, error,
module::{self, InvariantHandler as _, Module as _},
types::{
token,
transaction::{
self, AddressSpec, AuthProof, Call, CallFormat, TransactionWeight,
UnverifiedTransaction,
},
},
Runtime,
};
#[cfg(test)]
mod test;
pub mod types;
/// Unique module name.
pub const MODULE_NAME: &str = "core";
/// Errors emitted by the core module.
#[derive(Error, Debug, oasis_runtime_sdk_macros::Error)]
pub enum Error {
#[error("malformed transaction: {0}")]
#[sdk_error(code = 1)]
MalformedTransaction(#[source] anyhow::Error),
#[error("invalid transaction: {0}")]
#[sdk_error(code = 2)]
InvalidTransaction(#[from] transaction::Error),
#[error("invalid method: {0}")]
#[sdk_error(code = 3)]
InvalidMethod(String),
#[error("invalid nonce")]
#[sdk_error(code = 4)]
InvalidNonce,
#[error("insufficient balance to pay fees")]
#[sdk_error(code = 5)]
InsufficientFeeBalance,
#[error("out of message slots")]
#[sdk_error(code = 6)]
OutOfMessageSlots,
#[error("message handler not invoked")]
#[sdk_error(code = 8)]
MessageHandlerNotInvoked,
#[error("missing message handler")]
#[sdk_error(code = 9)]
MessageHandlerMissing(u32),
#[error("invalid argument: {0}")]
#[sdk_error(code = 10)]
InvalidArgument(#[source] anyhow::Error),
#[error("gas overflow")]
#[sdk_error(code = 11)]
GasOverflow,
#[error("out of gas (limit: {0} wanted: {1})")]
#[sdk_error(code = 12)]
OutOfGas(u64, u64),
#[error("batch gas overflow")]
#[sdk_error(code = 13)]
BatchGasOverflow,
#[error("batch out of gas (limit: {0} wanted: {1})")]
#[sdk_error(code = 14)]
BatchOutOfGas(u64, u64),
#[error("too many authentication slots")]
#[sdk_error(code = 15)]
TooManyAuth,
#[error("multisig too many signers")]
#[sdk_error(code = 16)]
MultisigTooManySigners,
#[error("invariant violation: {0}")]
#[sdk_error(code = 17)]
InvariantViolation(String),
#[error("invalid call format: {0}")]
#[sdk_error(code = 18)]
InvalidCallFormat(#[source] anyhow::Error),
#[error("{0}")]
#[sdk_error(transparent, abort)]
Abort(#[source] dispatcher::Error),
#[error("no module could authenticate the transaction")]
#[sdk_error(code = 19)]
NotAuthenticated,
#[error("gas price too low")]
#[sdk_error(code = 20)]
GasPriceTooLow,
}
/// Gas costs.
#[derive(Clone, Debug, Default, cbor::Encode, cbor::Decode)]
pub struct GasCosts {
pub tx_byte: u64,
pub auth_signature: u64,
pub auth_multisig_signer: u64,
pub callformat_x25519_deoxysii: u64,
}
/// Parameters for the core module.
#[derive(Clone, Debug, Default, cbor::Encode, cbor::Decode)]
pub struct Parameters {
pub max_batch_gas: u64,
pub max_tx_signers: u32,
pub max_multisig_signers: u32,
pub gas_costs: GasCosts,
pub min_gas_price: BTreeMap<token::Denomination, u128>,
}
impl module::Parameters for Parameters {
type Error = std::convert::Infallible;
}
pub trait API {
/// Attempt to use gas. If the gas specified would cause either total used to exceed
/// its limit, fails with Error::OutOfGas or Error::BatchOutOfGas, and neither gas usage is
/// increased.
fn use_batch_gas<C: Context>(ctx: &mut C, gas: u64) -> Result<(), Error>;
/// Attempt to use gas. If the gas specified would cause either total used to exceed
/// its limit, fails with Error::OutOfGas or Error::BatchOutOfGas, and neither gas usage is
/// increased.
fn use_tx_gas<C: TxContext>(ctx: &mut C, gas: u64) -> Result<(), Error>;
/// Return the remaining gas.
fn remaining_tx_gas<C: TxContext>(ctx: &mut C) -> u64;
/// Increase transaction priority for the provided amount.
fn add_priority<C: Context>(ctx: &mut C, priority: u64) -> Result<(), Error>;
/// Increase the specific transaction weight for the provided amount.
fn add_weight<C: TxContext>(
ctx: &mut C,
weight: TransactionWeight,
val: u64,
) -> Result<(), Error>;
/// Takes the stored transaction weight.
fn take_weights<C: Context>(ctx: &mut C) -> BTreeMap<TransactionWeight, u64>;
/// Takes and returns the stored transaction priority.
fn take_priority<C: Context>(ctx: &mut C) -> u64;
}
/// Genesis state for the accounts module.
#[derive(Clone, Debug, Default, cbor::Encode, cbor::Decode)]
pub struct Genesis {
pub parameters: Parameters,
}
/// State schema constants.
pub mod state {
/// Runtime metadata.
pub const METADATA: &[u8] = &[0x01];
/// Map of message idx to message handlers for messages emitted in previous round.
pub const MESSAGE_HANDLERS: &[u8] = &[0x02];
}
pub struct Module;
const CONTEXT_KEY_GAS_USED: &str = "core.GasUsed";
const CONTEXT_KEY_PRIORITY: &str = "core.Priority";
const CONTEXT_KEY_WEIGHTS: &str = "core.Weights";
const GAS_WEIGHT_NAME: &str = "gas";
impl Module {
/// Initialize state from genesis.
pub fn init<C: Context>(ctx: &mut C, genesis: Genesis) {
// Set genesis parameters.
Self::set_params(ctx.runtime_state(), genesis.parameters);
}
/// Migrate state from a previous version.
fn migrate<C: Context>(_ctx: &mut C, _from: u32) -> bool {
// No migrations currently supported.
false
}
}
impl API for Module {
fn use_batch_gas<C: Context>(ctx: &mut C, gas: u64) -> Result<(), Error> {
// Do not enforce batch limits for check-tx.
if ctx.is_check_only() {
return Ok(());
}
let batch_gas_limit = Self::params(ctx.runtime_state()).max_batch_gas;
let batch_gas_used = ctx.value::<u64>(CONTEXT_KEY_GAS_USED).or_default();
let batch_new_gas_used = batch_gas_used
.checked_add(gas)
.ok_or(Error::BatchGasOverflow)?;
if batch_new_gas_used > batch_gas_limit {
return Err(Error::BatchOutOfGas(batch_gas_limit, batch_new_gas_used));
}
ctx.value::<u64>(CONTEXT_KEY_GAS_USED)
.set(batch_new_gas_used);
Ok(())
}
fn use_tx_gas<C: TxContext>(ctx: &mut C, gas: u64) -> Result<(), Error> {
let gas_limit = ctx.tx_auth_info().fee.gas;
let gas_used = ctx.tx_value::<u64>(CONTEXT_KEY_GAS_USED).or_default();
let new_gas_used = {
let sum = gas_used.checked_add(gas).ok_or(Error::GasOverflow)?;
if sum > gas_limit {
return Err(Error::OutOfGas(gas_limit, sum));
}
sum
};
Self::use_batch_gas(ctx, gas)?;
*ctx.tx_value::<u64>(CONTEXT_KEY_GAS_USED).or_default() = new_gas_used;
Self::add_weight(ctx, GAS_WEIGHT_NAME.into(), gas)?;
Ok(())
}
fn remaining_tx_gas<C: TxContext>(ctx: &mut C) -> u64 {
let gas_limit = ctx.tx_auth_info().fee.gas;
let gas_used = ctx.tx_value::<u64>(CONTEXT_KEY_GAS_USED).or_default();
gas_limit.saturating_sub(*gas_used)
}
fn add_priority<C: Context>(ctx: &mut C, priority: u64) -> Result<(), Error> {
let p = ctx.value::<u64>(CONTEXT_KEY_PRIORITY).or_default();
let added_p = p.checked_add(priority).unwrap_or(u64::MAX);
ctx.value::<u64>(CONTEXT_KEY_PRIORITY).set(added_p);
Ok(())
}
fn add_weight<C: TxContext>(
ctx: &mut C,
weight: TransactionWeight,
val: u64,
) -> Result<(), Error> {
let weights = ctx
.value::<BTreeMap<TransactionWeight, u64>>(CONTEXT_KEY_WEIGHTS)
.or_default();
let w = weights.remove(&weight).unwrap_or_default();
let added_w = w.checked_add(val).unwrap_or(u64::MAX);
weights.insert(weight, added_w);
Ok(())
}
fn take_priority<C: Context>(ctx: &mut C) -> u64 {
ctx.value::<u64>(CONTEXT_KEY_PRIORITY)
.take()
.unwrap_or_default()
}
fn take_weights<C: Context>(ctx: &mut C) -> BTreeMap<TransactionWeight, u64> {
ctx.value::<BTreeMap<TransactionWeight, u64>>(CONTEXT_KEY_WEIGHTS)
.take()
.unwrap_or_default()
}
}
impl Module {
/// Run a transaction in simulation and return how much gas it uses. This looks up the method
/// in the context's method registry. Transactions that fail still use gas, and this query will
/// estimate that and return successfully, so do not use this query to see if a transaction will
/// succeed.
fn query_estimate_gas<C: Context>(
ctx: &mut C,
mut args: transaction::Transaction,
) -> Result<u64, Error> {
// Assume maximum amount of gas and a reasonable maximum fee.
args.auth_info.fee.gas = u64::MAX;
args.auth_info.fee.amount =
token::BaseUnits::new(u64::MAX.into(), token::Denomination::NATIVE);
// Estimate transaction size. Since the transaction given to us is not signed, we need to
// estimate how large each of the auth proofs would be.
let auth_proofs: Result<_, Error> = args
.auth_info
.signer_info
.iter()
.map(|si| match si.address_spec {
// For the signature address spec we assume a signature auth proof of 64 bytes.
transaction::AddressSpec::Signature(_) => {
Ok(transaction::AuthProof::Signature(vec![0; 64].into()))
}
// For the multisig address spec assume all the signers sign with a 64-byte signature.
transaction::AddressSpec::Multisig(ref cfg) => {
Ok(transaction::AuthProof::Multisig(
cfg.signers
.iter()
.map(|_| Some(vec![0; 64].into()))
.collect(),
))
}
// Internal address specs should never appear as they are not serializable.
transaction::AddressSpec::Internal(_) => Err(Error::MalformedTransaction(anyhow!(
"internal address spec used"
))),
})
.collect();
let tx_envelope =
transaction::UnverifiedTransaction(cbor::to_vec(args.clone()), auth_proofs?);
let tx_size: u32 = cbor::to_vec(tx_envelope)
.len()
.try_into()
.map_err(|_| Error::InvalidArgument(anyhow!("transaction too large")))?;
ctx.with_simulation(|mut sim_ctx| {
sim_ctx.with_tx(tx_size, args, |mut tx_ctx, call| {
dispatcher::Dispatcher::<C::Runtime>::dispatch_tx_call(&mut tx_ctx, call);
// Warning: we don't report success or failure. If the call fails, we still report
// how much gas it uses while it fails.
Ok(*tx_ctx.value::<u64>(CONTEXT_KEY_GAS_USED).or_default())
})
})
}
/// Check invariants of all modules in the runtime.
fn query_check_invariants<C: Context>(ctx: &mut C, _args: ()) -> Result<(), Error> {
if !ctx.are_expensive_queries_allowed() {
return Err(Error::InvalidArgument(anyhow!("query not allowed")));
}
<C::Runtime as Runtime>::Modules::check_invariants(ctx)
}
/// Retrieve the public key for encrypting call data.
fn query_calldata_public_key<C: Context>(
ctx: &mut C,
_args: (),
) -> Result<types::CallDataPublicKeyQueryResponse, Error> {
let key_manager = ctx
.key_manager()
.ok_or_else(|| Error::InvalidArgument(anyhow!("key manager not available")))?;
let public_key = key_manager
.get_public_key(callformat::get_key_pair_id(ctx))
.map_err(|err| Error::Abort(err.into()))?
.ok_or_else(|| Error::InvalidArgument(anyhow!("key not available")))?;
Ok(types::CallDataPublicKeyQueryResponse { public_key })
}
/// Query the minimum gas price.
fn query_min_gas_price<C: Context>(
ctx: &mut C,
_args: (),
) -> Result<BTreeMap<token::Denomination, u128>, Error> {
let params = Self::params(ctx.runtime_state());
Ok(params.min_gas_price)
}
}
impl module::Module for Module {
const NAME: &'static str = MODULE_NAME;
type Error = Error;
type Event = ();
type Parameters = Parameters;
}
impl module::AuthHandler for Module {
fn approve_unverified_tx<C: Context>(
ctx: &mut C,
utx: &UnverifiedTransaction,
) -> Result<(), Error> {
let params = Self::params(ctx.runtime_state());
if utx.1.len() > params.max_tx_signers as usize {
return Err(Error::TooManyAuth);
}
for auth_proof in &utx.1 {
if let AuthProof::Multisig(config) = auth_proof {
if config.len() > params.max_multisig_signers as usize {
return Err(Error::MultisigTooManySigners);
}
}
}
Ok(())
}
fn before_handle_call<C: TxContext>(ctx: &mut C, call: &Call) -> Result<(), Error> {
let params = Self::params(ctx.runtime_state());
// Check that the fee's denomination is in the min_gas_price map and
// that the gas price is higher or equal than the set minimum.
let fee = ctx.tx_auth_info().fee.clone();
match params.min_gas_price.get(fee.amount.denomination()) {
None => return Err(Error::GasPriceTooLow),
Some(min_gas_price) => {
if &fee.gas_price() < min_gas_price {
return Err(Error::GasPriceTooLow);
}
}
}
// Charge gas for transaction size.
Self::use_tx_gas(
ctx,
params
.gas_costs
.tx_byte
.checked_mul(ctx.tx_size().into())
.ok_or(Error::GasOverflow)?,
)?;
// Charge gas for signature verification.
let mut num_signature: u64 = 0;
let mut num_multisig_signer: u64 = 0;
for si in &ctx.tx_auth_info().signer_info {
match &si.address_spec {
AddressSpec::Signature(_) => {
num_signature = num_signature.checked_add(1).ok_or(Error::GasOverflow)?;
}
AddressSpec::Multisig(config) => {
num_multisig_signer = num_multisig_signer
.checked_add(config.signers.len() as u64)
.ok_or(Error::GasOverflow)?;
}
AddressSpec::Internal(_) => {}
}
}
let total = (|| {
let signature_cost = num_signature.checked_mul(params.gas_costs.auth_signature)?;
let multisig_signer_cost =
num_multisig_signer.checked_mul(params.gas_costs.auth_multisig_signer)?;
let sum = signature_cost.checked_add(multisig_signer_cost)?;
Some(sum)
})()
.ok_or(Error::GasOverflow)?;
Self::use_tx_gas(ctx, total)?;
// Charge gas for callformat.
match call.format {
CallFormat::Plain => {} // No additional gas required.
CallFormat::EncryptedX25519DeoxysII => {
Self::use_tx_gas(ctx, params.gas_costs.callformat_x25519_deoxysii)?
}
}
// Attempt to limit the maximum number of consensus messages and add appropriate weights.
let consensus_messages = ctx.tx_auth_info().fee.consensus_messages;
ctx.limit_max_messages(consensus_messages)?;
Self::add_weight(
ctx,
TransactionWeight::ConsensusMessages,
consensus_messages as u64,
)?;
Ok(())
}
}
impl module::MigrationHandler for Module {
type Genesis = Genesis;
fn init_or_migrate<C: Context>(
ctx: &mut C,
meta: &mut types::Metadata,
genesis: Self::Genesis,
) -> bool {
let version = meta.versions.get(Self::NAME).copied().unwrap_or_default();
if version == 0 {
// Initialize state from genesis.
Self::init(ctx, genesis);
meta.versions.insert(Self::NAME.to_owned(), Self::VERSION);
return true;
}
// Perform migration.
Self::migrate(ctx, version)
}
}
impl module::MethodHandler for Module {
fn dispatch_query<C: Context>(
ctx: &mut C,
method: &str,
args: cbor::Value,
) -> module::DispatchResult<cbor::Value, Result<cbor::Value, error::RuntimeError>> {
match method {
"core.EstimateGas" => module::dispatch_query(ctx, args, Self::query_estimate_gas),
"core.CheckInvariants" => {
module::dispatch_query(ctx, args, Self::query_check_invariants)
}
"core.CallDataPublicKey" => {
module::dispatch_query(ctx, args, Self::query_calldata_public_key)
}
"core.MinGasPrice" => module::dispatch_query(ctx, args, Self::query_min_gas_price),
_ => module::DispatchResult::Unhandled(args),
}
}
}
impl module::BlockHandler for Module {
fn get_block_weight_limits<C: Context>(ctx: &mut C) -> BTreeMap<TransactionWeight, u64> {
let batch_gas_limit = Self::params(ctx.runtime_state()).max_batch_gas;
let mut res = BTreeMap::new();
res.insert(GAS_WEIGHT_NAME.into(), batch_gas_limit);
res
}
}
impl module::InvariantHandler for Module {}
|
use anyhow::Result;
use image::RgbaImage;
use std::sync::Arc;
#[derive(Debug)]
pub struct Texture {
pub texture: Arc<wgpu::Texture>,
pub size: wgpu::Extent3d,
pub group: wgpu::BindGroup,
pub layout: wgpu::BindGroupLayout,
pub view: wgpu::TextureView,
pub sampler: wgpu::Sampler,
}
impl Texture {
pub fn new(rgba: &RgbaImage, device: &wgpu::Device, queue: &wgpu::Queue) -> Self {
let dimensions = rgba.dimensions();
// create texture
let texture_size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
};
let diffuse_texture = TextureExt::diffuse_texture(texture_size, device);
TextureExt::upload_to_gpu(&diffuse_texture, rgba, texture_size, queue).unwrap();
// create gpu layout
let (view, sampler) = TextureExt::view(&diffuse_texture, device);
let (layout, group) = TextureExt::layout(&view, &sampler, device);
Self {
texture: Arc::new(diffuse_texture),
size: texture_size,
group,
layout,
view,
sampler,
}
}
}
struct TextureExt;
impl TextureExt {
pub fn diffuse_texture(texture_size: wgpu::Extent3d, device: &wgpu::Device) -> wgpu::Texture {
device.create_texture(&wgpu::TextureDescriptor {
// All textures are stored as 3D, we represent our 2D texture
// by setting depth to 1.
size: texture_size,
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb,
// SAMPLED tells wgpu that we want to use this texture in shaders
// COPY_DST means that we want to copy data to this texture
usage: wgpu::TextureUsage::SAMPLED | wgpu::TextureUsage::COPY_DST,
label: Some("diffuse_texture"),
})
}
pub fn view(
texture: &wgpu::Texture, device: &wgpu::Device,
) -> (wgpu::TextureView, wgpu::Sampler) {
let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Nearest,
mipmap_filter: wgpu::FilterMode::Nearest,
..Default::default()
});
(view, sampler)
}
pub fn layout(
view: &wgpu::TextureView, sampler: &wgpu::Sampler, device: &wgpu::Device,
) -> (wgpu::BindGroupLayout, wgpu::BindGroup) {
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::SampledTexture {
multisampled: false,
dimension: wgpu::TextureViewDimension::D2,
component_type: wgpu::TextureComponentType::Float,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::Sampler { comparison: false },
count: None,
},
],
label: Some("texture_bind_group_layout"),
});
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(sampler),
},
],
label: Some("diffuse_bind_group"),
});
(layout, group)
}
pub fn upload_to_gpu(
texture: &wgpu::Texture, contents: &[u8], texture_size: wgpu::Extent3d, queue: &wgpu::Queue,
) -> Result<()> {
queue.write_texture(
wgpu::TextureCopyView {
texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
contents,
wgpu::TextureDataLayout {
offset: 0,
bytes_per_row: 4 * texture_size.width,
rows_per_image: texture_size.height,
},
texture_size,
);
Ok(())
}
}
|
#![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
#[cfg(feature = "UI_Input_Preview_Injection")]
pub mod Injection;
#[repr(transparent)]
#[doc(hidden)]
pub struct IInputActivationListenerPreviewStatics(pub ::windows::core::IInspectable);
unsafe impl ::windows::core::Interface for IInputActivationListenerPreviewStatics {
type Vtable = IInputActivationListenerPreviewStatics_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf0551ce5_0de6_5be0_a589_f737201a4582);
}
#[repr(C)]
#[doc(hidden)]
pub struct IInputActivationListenerPreviewStatics_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32, values: *mut *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut i32) -> ::windows::core::HRESULT,
#[cfg(feature = "UI_WindowManagement")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, window: ::windows::core::RawPtr, result__: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "UI_WindowManagement"))] usize,
);
pub struct InputActivationListenerPreview {}
impl InputActivationListenerPreview {
#[cfg(feature = "UI_WindowManagement")]
pub fn CreateForApplicationWindow<'a, Param0: ::windows::core::IntoParam<'a, super::super::WindowManagement::AppWindow>>(window: Param0) -> ::windows::core::Result<super::InputActivationListener> {
Self::IInputActivationListenerPreviewStatics(|this| unsafe {
let mut result__: ::windows::core::RawPtr = ::core::mem::zeroed();
(::windows::core::Interface::vtable(this).6)(::core::mem::transmute_copy(this), window.into_param().abi(), &mut result__).from_abi::<super::InputActivationListener>(result__)
})
}
pub fn IInputActivationListenerPreviewStatics<R, F: FnOnce(&IInputActivationListenerPreviewStatics) -> ::windows::core::Result<R>>(callback: F) -> ::windows::core::Result<R> {
static mut SHARED: ::windows::core::FactoryCache<InputActivationListenerPreview, IInputActivationListenerPreviewStatics> = ::windows::core::FactoryCache::new();
unsafe { SHARED.call(callback) }
}
}
impl ::windows::core::RuntimeName for InputActivationListenerPreview {
const NAME: &'static str = "Windows.UI.Input.Preview.InputActivationListenerPreview";
}
|
pub struct Solution;
#[derive(Debug, PartialEq, Eq)]
pub struct TreeNode {
pub val: i32,
pub left: Tree,
pub right: Tree,
}
use std::cell::RefCell;
use std::rc::Rc;
type Tree = Option<Rc<RefCell<TreeNode>>>;
impl Solution {
pub fn max_path_sum(root: Tree) -> i32 {
rec(&root).unwrap().0
}
}
fn rec(root: &Tree) -> Option<(i32, i32)> {
match root {
None => None,
Some(node) => {
let val = node.borrow().val;
match (rec(&node.borrow().left), rec(&node.borrow().right)) {
(None, None) => Some((val, val)),
(Some((a, b)), None) | (None, Some((a, b))) => {
Some((a.max(val + b.max(0)), val + b.max(0)))
}
(Some((a, b)), Some((c, d))) => Some((
a.max(c).max(val + b.max(0) + d.max(0)),
val + b.max(d).max(0),
)),
}
}
}
}
#[test]
fn test0124() {
let tree = |val, left, right| Some(Rc::new(RefCell::new(TreeNode { val, left, right })));
assert_eq!(
Solution::max_path_sum(tree(1, tree(2, None, None), tree(3, None, None),)),
6
);
assert_eq!(
Solution::max_path_sum(tree(
-10,
tree(9, None, None),
tree(20, tree(15, None, None), tree(7, None, None))
)),
42
);
}
|
use super::super::store::wasm_store_t;
use super::super::trap::wasm_trap_t;
use super::super::types::{wasm_functype_t, wasm_valkind_enum};
use super::super::value::{wasm_val_inner, wasm_val_t};
use std::convert::TryInto;
use std::ffi::c_void;
use std::sync::Arc;
use wasmer::{Function, Instance, RuntimeError, Val};
#[allow(non_camel_case_types)]
pub struct wasm_func_t {
pub(crate) inner: Function,
// this is how we ensure the instance stays alive
pub(crate) instance: Option<Arc<Instance>>,
}
#[allow(non_camel_case_types)]
pub type wasm_func_callback_t =
unsafe extern "C" fn(args: *const wasm_val_t, results: *mut wasm_val_t) -> *mut wasm_trap_t;
#[allow(non_camel_case_types)]
pub type wasm_func_callback_with_env_t = unsafe extern "C" fn(
*mut c_void,
args: *const wasm_val_t,
results: *mut wasm_val_t,
) -> *mut wasm_trap_t;
#[allow(non_camel_case_types)]
pub type wasm_env_finalizer_t = unsafe extern "C" fn(c_void);
#[no_mangle]
pub unsafe extern "C" fn wasm_func_new(
store: &wasm_store_t,
ft: &wasm_functype_t,
callback: wasm_func_callback_t,
) -> Option<Box<wasm_func_t>> {
// TODO: handle null pointers?
let func_sig = ft.sig();
let num_rets = func_sig.results().len();
let inner_callback = move |args: &[Val]| -> Result<Vec<Val>, RuntimeError> {
let processed_args = args
.into_iter()
.map(TryInto::try_into)
.collect::<Result<Vec<wasm_val_t>, _>>()
.expect("Argument conversion failed");
let mut results = vec![
wasm_val_t {
kind: wasm_valkind_enum::WASM_I64 as _,
of: wasm_val_inner { int64_t: 0 },
};
num_rets
];
let trap = callback(processed_args.as_ptr(), results.as_mut_ptr());
if !trap.is_null() {
let trap: Box<wasm_trap_t> = Box::from_raw(trap);
RuntimeError::raise(Box::new(trap.inner));
}
let processed_results = results
.into_iter()
.map(TryInto::try_into)
.collect::<Result<Vec<Val>, _>>()
.expect("Result conversion failed");
Ok(processed_results)
};
let function = Function::new(&store.inner, &func_sig, inner_callback);
Some(Box::new(wasm_func_t {
instance: None,
inner: function,
}))
}
#[no_mangle]
pub unsafe extern "C" fn wasm_func_new_with_env(
store: &wasm_store_t,
ft: &wasm_functype_t,
callback: wasm_func_callback_with_env_t,
env: *mut c_void,
finalizer: wasm_env_finalizer_t,
) -> Option<Box<wasm_func_t>> {
// TODO: handle null pointers?
let func_sig = ft.sig();
let num_rets = func_sig.results().len();
let inner_callback =
move |env: &mut *mut c_void, args: &[Val]| -> Result<Vec<Val>, RuntimeError> {
let processed_args = args
.into_iter()
.map(TryInto::try_into)
.collect::<Result<Vec<wasm_val_t>, _>>()
.expect("Argument conversion failed");
let mut results = vec![
wasm_val_t {
kind: wasm_valkind_enum::WASM_I64 as _,
of: wasm_val_inner { int64_t: 0 },
};
num_rets
];
let _traps = callback(*env, processed_args.as_ptr(), results.as_mut_ptr());
// TODO: do something with `traps`
let processed_results = results
.into_iter()
.map(TryInto::try_into)
.collect::<Result<Vec<Val>, _>>()
.expect("Result conversion failed");
Ok(processed_results)
};
let function = Function::new_with_env(&store.inner, &func_sig, env, inner_callback);
Some(Box::new(wasm_func_t {
instance: None,
inner: function,
}))
}
#[no_mangle]
pub unsafe extern "C" fn wasm_func_delete(_func: Option<Box<wasm_func_t>>) {}
#[no_mangle]
pub unsafe extern "C" fn wasm_func_call(
func: &wasm_func_t,
args: *const wasm_val_t,
results: *mut wasm_val_t,
) -> Option<Box<wasm_trap_t>> {
let num_params = func.inner.ty().params().len();
let params: Vec<Val> = (0..num_params)
.map(|i| (&(*args.add(i))).try_into())
.collect::<Result<_, _>>()
.ok()?;
match func.inner.call(¶ms) {
Ok(wasm_results) => {
for (i, actual_result) in wasm_results.iter().enumerate() {
let result_loc = &mut (*results.add(i));
*result_loc = (&*actual_result).try_into().ok()?;
}
None
}
Err(e) => Some(Box::new(e.into())),
}
}
#[no_mangle]
pub unsafe extern "C" fn wasm_func_param_arity(func: &wasm_func_t) -> usize {
func.inner.ty().params().len()
}
#[no_mangle]
pub unsafe extern "C" fn wasm_func_result_arity(func: &wasm_func_t) -> usize {
func.inner.ty().results().len()
}
|
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize)]
pub struct Triangle {
pub enabled: bool,
pos: usize,
timer_value: u16,
timer_period: u16,
lcl: u8,
control: bool,
length_counter: u8,
length_table: Vec<u8>,
// Linear counter
lc_value: u8,
lc_reload_flag: bool,
lc_reload_value: u8,
}
impl Triangle {
pub fn new() -> Triangle {
Triangle {
enabled: true,
pos: 0,
timer_value: 0,
timer_period: 0,
lcl: 0,
control: false,
length_counter: 0,
length_table: vec![
10, 254, 20, 2, 40, 4, 80, 6, 160, 8, 60, 10, 14, 12, 26, 14, 12, 16, 24, 18, 48,
20, 96, 22, 192, 24, 72, 26, 16, 28, 32, 30,
],
lc_value: 0,
lc_reload_flag: false,
lc_reload_value: 0,
}
}
pub fn write_control(&mut self, value: u8) {
self.control = (value & 0x80) == 0;
self.lc_reload_value = value & 0x7F;
}
pub fn write_timer_low(&mut self, value: u8) {
self.timer_period = (0xFF00 & self.timer_period) | value as u16;
}
pub fn write_timer_high(&mut self, value: u8) {
self.length_counter = self.length_table[(value >> 3) as usize];
self.timer_period = (0x00FF & self.timer_period) | ((value as u16 & 0x7) << 8);
self.timer_value = self.timer_period;
self.lc_reload_flag = true;
}
pub fn on_quarter_frame(&mut self) {
if self.lc_reload_flag {
self.lc_value = self.lc_reload_value;
} else if self.lc_value != 0 {
self.lc_value -= 1;
}
if self.control {
self.lc_reload_flag = false;
}
}
pub fn on_half_frame(&mut self) {
if self.control && self.length_counter > 0 {
self.length_counter -= 1;
}
}
pub fn cycle(&mut self) {
if self.timer_value == 0 {
if self.lc_value > 0 && self.length_counter > 0 {
self.pos += 1;
self.pos %= 32;
}
self.timer_value = self.timer_period;
} else {
self.timer_value -= 1;
}
}
pub fn output(&self) -> u8 {
let triangle = [
15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15,
];
if self.lc_value == 0 || self.length_counter == 0 || !self.enabled {
0
} else {
triangle[self.pos]
}
}
pub fn set_enabled(&mut self, enabled: bool) {
self.enabled = enabled;
if !self.enabled {
self.length_counter = 0;
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn triangle_cycle() {
// Loop over given range and verify that it repeats
let triangle = [
15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15,
];
let mut tri = Triangle::new();
tri.lc_value = 10;
tri.length_counter = 10;
for t in triangle.iter() {
assert_eq!(tri.output(), *t as u8);
tri.cycle();
}
assert_eq!(tri.output(), 15);
}
#[test]
fn triangle_period() {
let mut tri = Triangle::new();
tri.lc_value = 10;
tri.length_counter = 10;
tri.timer_value = 2;
tri.timer_period = 2;
assert_eq!(tri.output(), 15);
tri.cycle();
assert_eq!(tri.output(), 15);
tri.cycle();
assert_eq!(tri.output(), 15);
tri.cycle();
assert_eq!(tri.output(), 14);
}
}
|
//! Settings variables used throughout the project.
// Gameplay
pub const BALL_SPAWN_DELAY: f32 = 2.0;
// Audio - sfx
pub const BOUNCE_SFX: &str = "audio/sfx/bounce.ogg";
pub const SCORE_SFX: &str = "audio/sfx/score.ogg";
// Audio - tracks
pub const MUSIC_TRACKS: &[&str] = &["audio/tracks/track-01.ogg", "audio/tracks/track-02.ogg"];
// Arena (game window) settings
pub const ARENA_WIDTH: f32 = 100.0;
pub const ARENA_HEIGHT: f32 = 100.0;
// Ball definitions
pub const BALL_VELOCITY_X: f32 = 75.0;
pub const BALL_VELOCITY_Y: f32 = 50.0;
pub const BALL_RADIUS: f32 = 2.0;
// Paddle definitions
pub const PADDLE_WIDTH: f32 = 4.0;
pub const PADDLE_HEIGHT: f32 = 16.0;
// Assets paths
pub const SQUARE_FONT_PATH: &str = "fonts/square.ttf";
pub const SPRITE_SHEET_PATH: &str = "textures/spritesheet.png";
pub const SPRITE_SHEET_ATLAS_PATH: &str = "textures/spritesheet.ron";
|
use super::{Header, Id};
use std::fs::{File};
use std::path::PathBuf;
use std::mem::size_of;
use std::io;
use std::io::{Read, Seek, SeekFrom};
use crate::archives::packages::patches::index::{IndirectIndex, EntriesMeta, BlocksMeta};
use crate::archives::packages::patches::index::IndexStrategy::{DIRECT, INDIRECT};
use crate::archives::packages::patches::{Count, Entry, Block};
use std::alloc::Layout;
fn vec_to_string(vector: Vec<String>) -> io::Result<String> {
let mut result = String::new();
for i in 0..vector.len() {
result.push_str(&(vector[i]));
if i < vector.len() - 1 {
result.push_str("_");
}
}
Ok(result)
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub struct FileInfo {
pub filename: String,
pub platform: String,
pub description: String,
pub package_id: Id,
pub patch_id: Id,
pub language: String,
pub header: Header,
pub indirect_index: IndirectIndex,
path: PathBuf,
}
impl FileInfo {
pub fn from_path(path: PathBuf) -> FileInfo {
let filename = String::from(
path.file_stem().expect(
"Could not get file stem"
).to_str().expect(
"Could not convert file stem to string!"
)
);
let mut chunks: Vec<String> = filename.split('_').map(
|value| value.to_string()
).collect();
let mut file: File = File::open(&path).expect("File open failed during construction!");
let platform = chunks.remove(0);
let patch_id = Id::from_str_radix(
&chunks.pop().expect("Could not pop Id from filename vector!"),
16).expect("Id in filename is not valid hex!");
let package_id: Id;
let language: String;
let before_patch_id = chunks.pop().expect("Could not pop value prior to patch_id!");
if before_patch_id.len() == 2 {
language = before_patch_id;
} else {
language = String::from("NA");
}
let header_result = Header::unpack_from_file(file);
let header = header_result.0;
package_id = header.package_id;
file = header_result.1;
let indirect_index: IndirectIndex;
if header.index.indirect_index_offset > 0 {
file.seek(
SeekFrom::Start(header.index.indirect_index_offset as u64)
).expect("Unable to seek to indirect index");
let indirect_index_result = IndirectIndex::unpack_from_file(file);
indirect_index = indirect_index_result.0;
} else {
indirect_index = IndirectIndex::default();
}
FileInfo {
filename,
platform,
description: vec_to_string(chunks).expect("Could not prepare description!"),
package_id,
patch_id,
language,
header,
indirect_index,
path,
}
}
pub fn get_entry_count(&self) -> Count {
if self.header.format == DIRECT {
self.header.index.entry_count
} else if self.header.format == INDIRECT {
self.indirect_index.entry_count
} else {
0
}
}
pub fn get_entries_offset(&self) -> u64 {
if self.header.format == DIRECT {
self.header.index.entries_offset as u64
} else if self.header.format == INDIRECT {
self.header.index.indirect_index_offset as u64 +
self.indirect_index.entries_meta_offset as u64 +
size_of::<EntriesMeta>() as u64
} else {
0 as u64
}
}
pub fn get_block_count(&self) -> Count {
if self.header.format == DIRECT {
self.header.index.block_count
} else if self.header.format == INDIRECT {
self.indirect_index.block_count
} else {
0
}
}
pub fn get_blocks_offset(&self) -> u64 {
if self.header.format == DIRECT {
self.header.index.blocks_offset as u64
} else if self.header.format == INDIRECT {
self.header.index.indirect_index_offset as u64 +
self.indirect_index.blocks_meta_offset as u64 +
size_of::<BlocksMeta>() as u64
} else {
0 as u64
}
}
pub fn get_entries(&self) -> Vec<Entry> {
let mut file = self.get_file();
file.seek(SeekFrom::Start(self.get_entries_offset() as u64)).expect("Seek failed!");
let entry_count = self.get_entry_count();
Entry::unpack_slice_from_file(file, entry_count as usize).0
}
pub fn get_blocks(&self) -> Vec<Block> {
let mut file = self.get_file();
file.seek(SeekFrom::Start(self.get_blocks_offset() as u64)).expect("Seek failed!");
Block::unpack_slice_from_file(file, self.get_block_count() as usize).0
}
pub fn get_file(&self) -> File {
File::open(self.path.as_path()).expect("File open failed!")
}
}
pub trait PackedStruct<T> {
fn unpack_from_file(file: File) -> (T, File);
}
pub trait PackedStructs<T> where T: Clone {
fn unpack_slice_from_file(file: File, count: usize) -> (Vec<T>, File);
}
impl<T> PackedStruct<T> for T {
fn unpack_from_file(mut file: File) -> (T, File) {
let layout = Layout::new::<T>();
unsafe {
let pointer = std::alloc::alloc(layout) as *mut T;
let target = std::slice::from_raw_parts_mut(
pointer as *mut u8,
size_of::<T>()
);
file.read_exact(target).expect("Single struct read failed!");
(pointer.read(), file)
}
}
}
impl<T> PackedStructs<T> for T where T: Clone {
fn unpack_slice_from_file(mut file: File, count: usize) -> (Vec<T>, File) where T: Clone {
let layout = Layout::array::<u8>(
count * size_of::<T>()
).expect("Could not create layout!");
unsafe {
let pointer = std::alloc::alloc(layout) as *mut u8;
let target = std::slice::from_raw_parts_mut(
pointer,
count * size_of::<T>()
);
file.read_exact(target).expect("Slice read failed!");
let result = &*(target as *mut [u8] as *const [T]);
(result[0..count].to_vec(), file)
}
}
}
|
use super::Context;
use crate::projects::queries::QueryProjects;
use crate::stories::queries::QueryStories;
use crate::users::queries::QueryUsers;
pub struct QueryRoot;
#[juniper::graphql_object(
Context = Context
)]
impl QueryRoot {
fn users(&self) -> QueryUsers {
QueryUsers
}
fn projects(&self) -> QueryProjects {
QueryProjects
}
fn stories(&self) -> QueryStories {
QueryStories
}
}
|
struct Point {
x: i32,
y: i32,
}
enum Color {
Rgb(i32, i32, i32),
Hsv(i32, i32, i32)
}
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(Color),
}
fn main() {
let p = Point { x: 0, y: 7 };
// naming fields in struct
let Point { x: a, y: b } = p;
assert_eq!(0, a);
assert_eq!(7, b);
// using literals from struct
let Point { x, y } = p;
assert_eq!(0, x);
assert_eq!(7, y);
// destructuring nested structs and enums
let msg = Message::ChangeColor(Color::Hsv(0, 160, 255));
match msg {
Message::ChangeColor(Color::Rgb(r, g, b)) => {
println!(
"Change the color to red {}, green {}, and blue {}",
r,
g,
b
)
},
Message::ChangeColor(Color::Hsv(h, s, v)) => {
println!(
"Change the color to hue {}, saturation {}, and value {}",
h,
s,
v
)
}
_ => ()
}
// destructuring structs and tuples
let ((feet, inches), Point {x, y}) = ((3, 10), Point { x: 3, y: -10 });
println!("{}'{}''", feet, inches);
}
|
use gfx_maths::*;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct DirectionalLight {
pub direction: Vec4,
pub illuminance: Vec4, // in lx = lm / m^2
}
#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct PointLight {
pub position: Vec4,
pub luminous_flux: Vec4, // in lm
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Light {
Directional(DirectionalLight),
Point(PointLight),
}
impl From<PointLight> for Light {
fn from(value: PointLight) -> Self {
Light::Point(value)
}
}
impl From<DirectionalLight> for Light {
fn from(value: DirectionalLight) -> Self {
Light::Directional(value)
}
}
|
#[doc = "Reader of register TZSC_PRIVCFGR1"]
pub type R = crate::R<u32, super::TZSC_PRIVCFGR1>;
#[doc = "Writer for register TZSC_PRIVCFGR1"]
pub type W = crate::W<u32, super::TZSC_PRIVCFGR1>;
#[doc = "Register TZSC_PRIVCFGR1 `reset()`'s with value 0"]
impl crate::ResetValue for super::TZSC_PRIVCFGR1 {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `TIM2PRIV`"]
pub type TIM2PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TIM2PRIV`"]
pub struct TIM2PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> TIM2PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
#[doc = "Reader of field `TIM3PRIV`"]
pub type TIM3PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TIM3PRIV`"]
pub struct TIM3PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> TIM3PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Reader of field `TIM4PRIV`"]
pub type TIM4PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TIM4PRIV`"]
pub struct TIM4PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> TIM4PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
self.w
}
}
#[doc = "Reader of field `TIM5PRIV`"]
pub type TIM5PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TIM5PRIV`"]
pub struct TIM5PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> TIM5PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
self.w
}
}
#[doc = "Reader of field `TIM6PRIV`"]
pub type TIM6PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TIM6PRIV`"]
pub struct TIM6PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> TIM6PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Reader of field `TIM7PRIV`"]
pub type TIM7PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TIM7PRIV`"]
pub struct TIM7PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> TIM7PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
self.w
}
}
#[doc = "Reader of field `WWDGPRIV`"]
pub type WWDGPRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WWDGPRIV`"]
pub struct WWDGPRIV_W<'a> {
w: &'a mut W,
}
impl<'a> WWDGPRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
self.w
}
}
#[doc = "Reader of field `IWDGPRIV`"]
pub type IWDGPRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `IWDGPRIV`"]
pub struct IWDGPRIV_W<'a> {
w: &'a mut W,
}
impl<'a> IWDGPRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
self.w
}
}
#[doc = "Reader of field `SPI2PRIV`"]
pub type SPI2PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `SPI2PRIV`"]
pub struct SPI2PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> SPI2PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
self.w
}
}
#[doc = "Reader of field `SPI3PRIV`"]
pub type SPI3PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `SPI3PRIV`"]
pub struct SPI3PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> SPI3PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
self.w
}
}
#[doc = "Reader of field `USART2PRIV`"]
pub type USART2PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `USART2PRIV`"]
pub struct USART2PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> USART2PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
self.w
}
}
#[doc = "Reader of field `USART3PRIV`"]
pub type USART3PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `USART3PRIV`"]
pub struct USART3PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> USART3PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 11)) | (((value as u32) & 0x01) << 11);
self.w
}
}
#[doc = "Reader of field `UART4PRIV`"]
pub type UART4PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `UART4PRIV`"]
pub struct UART4PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> UART4PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
self.w
}
}
#[doc = "Reader of field `UART5PRIV`"]
pub type UART5PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `UART5PRIV`"]
pub struct UART5PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> UART5PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 13)) | (((value as u32) & 0x01) << 13);
self.w
}
}
#[doc = "Reader of field `I2C1PRIV`"]
pub type I2C1PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `I2C1PRIV`"]
pub struct I2C1PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> I2C1PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 14)) | (((value as u32) & 0x01) << 14);
self.w
}
}
#[doc = "Reader of field `I2C2PRIV`"]
pub type I2C2PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `I2C2PRIV`"]
pub struct I2C2PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> I2C2PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 15)) | (((value as u32) & 0x01) << 15);
self.w
}
}
#[doc = "Reader of field `I2C3PRIV`"]
pub type I2C3PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `I2C3PRIV`"]
pub struct I2C3PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> I2C3PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
self.w
}
}
#[doc = "Reader of field `CRSPRIV`"]
pub type CRSPRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `CRSPRIV`"]
pub struct CRSPRIV_W<'a> {
w: &'a mut W,
}
impl<'a> CRSPRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 17)) | (((value as u32) & 0x01) << 17);
self.w
}
}
#[doc = "Reader of field `DACPRIV`"]
pub type DACPRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `DACPRIV`"]
pub struct DACPRIV_W<'a> {
w: &'a mut W,
}
impl<'a> DACPRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 18)) | (((value as u32) & 0x01) << 18);
self.w
}
}
#[doc = "Reader of field `OPAMPPRIV`"]
pub type OPAMPPRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `OPAMPPRIV`"]
pub struct OPAMPPRIV_W<'a> {
w: &'a mut W,
}
impl<'a> OPAMPPRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 19)) | (((value as u32) & 0x01) << 19);
self.w
}
}
#[doc = "Reader of field `LPTIM1PRIV`"]
pub type LPTIM1PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `LPTIM1PRIV`"]
pub struct LPTIM1PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> LPTIM1PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 20)) | (((value as u32) & 0x01) << 20);
self.w
}
}
#[doc = "Reader of field `LPUART1PRIV`"]
pub type LPUART1PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `LPUART1PRIV`"]
pub struct LPUART1PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> LPUART1PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 21)) | (((value as u32) & 0x01) << 21);
self.w
}
}
#[doc = "Reader of field `I2C4PRIV`"]
pub type I2C4PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `I2C4PRIV`"]
pub struct I2C4PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> I2C4PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 22)) | (((value as u32) & 0x01) << 22);
self.w
}
}
#[doc = "Reader of field `LPTIM2PRIV`"]
pub type LPTIM2PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `LPTIM2PRIV`"]
pub struct LPTIM2PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> LPTIM2PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 23)) | (((value as u32) & 0x01) << 23);
self.w
}
}
#[doc = "Reader of field `LPTIM3PRIV`"]
pub type LPTIM3PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `LPTIM3PRIV`"]
pub struct LPTIM3PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> LPTIM3PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 24)) | (((value as u32) & 0x01) << 24);
self.w
}
}
#[doc = "Reader of field `FDCAN1PRIV`"]
pub type FDCAN1PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `FDCAN1PRIV`"]
pub struct FDCAN1PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> FDCAN1PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 25)) | (((value as u32) & 0x01) << 25);
self.w
}
}
#[doc = "Reader of field `USBFSPRIV`"]
pub type USBFSPRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `USBFSPRIV`"]
pub struct USBFSPRIV_W<'a> {
w: &'a mut W,
}
impl<'a> USBFSPRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 26)) | (((value as u32) & 0x01) << 26);
self.w
}
}
#[doc = "Reader of field `UCPD1PRIV`"]
pub type UCPD1PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `UCPD1PRIV`"]
pub struct UCPD1PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> UCPD1PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 27)) | (((value as u32) & 0x01) << 27);
self.w
}
}
#[doc = "Reader of field `VREFBUFPRIV`"]
pub type VREFBUFPRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `VREFBUFPRIV`"]
pub struct VREFBUFPRIV_W<'a> {
w: &'a mut W,
}
impl<'a> VREFBUFPRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 28)) | (((value as u32) & 0x01) << 28);
self.w
}
}
#[doc = "Reader of field `COMPPRIV`"]
pub type COMPPRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `COMPPRIV`"]
pub struct COMPPRIV_W<'a> {
w: &'a mut W,
}
impl<'a> COMPPRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 29)) | (((value as u32) & 0x01) << 29);
self.w
}
}
#[doc = "Reader of field `TIM1PRIV`"]
pub type TIM1PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TIM1PRIV`"]
pub struct TIM1PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> TIM1PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 30)) | (((value as u32) & 0x01) << 30);
self.w
}
}
#[doc = "Reader of field `SPI1PRIV`"]
pub type SPI1PRIV_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `SPI1PRIV`"]
pub struct SPI1PRIV_W<'a> {
w: &'a mut W,
}
impl<'a> SPI1PRIV_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 31)) | (((value as u32) & 0x01) << 31);
self.w
}
}
impl R {
#[doc = "Bit 0 - TIM2PRIV"]
#[inline(always)]
pub fn tim2priv(&self) -> TIM2PRIV_R {
TIM2PRIV_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - TIM3PRIV"]
#[inline(always)]
pub fn tim3priv(&self) -> TIM3PRIV_R {
TIM3PRIV_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - TIM4PRIV"]
#[inline(always)]
pub fn tim4priv(&self) -> TIM4PRIV_R {
TIM4PRIV_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - TIM5PRIV"]
#[inline(always)]
pub fn tim5priv(&self) -> TIM5PRIV_R {
TIM5PRIV_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - TIM6PRIV"]
#[inline(always)]
pub fn tim6priv(&self) -> TIM6PRIV_R {
TIM6PRIV_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - TIM7PRIV"]
#[inline(always)]
pub fn tim7priv(&self) -> TIM7PRIV_R {
TIM7PRIV_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - WWDGPRIV"]
#[inline(always)]
pub fn wwdgpriv(&self) -> WWDGPRIV_R {
WWDGPRIV_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 7 - IWDGPRIV"]
#[inline(always)]
pub fn iwdgpriv(&self) -> IWDGPRIV_R {
IWDGPRIV_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 8 - SPI2PRIV"]
#[inline(always)]
pub fn spi2priv(&self) -> SPI2PRIV_R {
SPI2PRIV_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 9 - SPI3PRIV"]
#[inline(always)]
pub fn spi3priv(&self) -> SPI3PRIV_R {
SPI3PRIV_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 10 - USART2PRIV"]
#[inline(always)]
pub fn usart2priv(&self) -> USART2PRIV_R {
USART2PRIV_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 11 - USART3PRIV"]
#[inline(always)]
pub fn usart3priv(&self) -> USART3PRIV_R {
USART3PRIV_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 12 - UART4PRIV"]
#[inline(always)]
pub fn uart4priv(&self) -> UART4PRIV_R {
UART4PRIV_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 13 - UART5PRIV"]
#[inline(always)]
pub fn uart5priv(&self) -> UART5PRIV_R {
UART5PRIV_R::new(((self.bits >> 13) & 0x01) != 0)
}
#[doc = "Bit 14 - I2C1PRIV"]
#[inline(always)]
pub fn i2c1priv(&self) -> I2C1PRIV_R {
I2C1PRIV_R::new(((self.bits >> 14) & 0x01) != 0)
}
#[doc = "Bit 15 - I2C2PRIV"]
#[inline(always)]
pub fn i2c2priv(&self) -> I2C2PRIV_R {
I2C2PRIV_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bit 16 - I2C3PRIV"]
#[inline(always)]
pub fn i2c3priv(&self) -> I2C3PRIV_R {
I2C3PRIV_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 17 - CRSPRIV"]
#[inline(always)]
pub fn crspriv(&self) -> CRSPRIV_R {
CRSPRIV_R::new(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 18 - DACPRIV"]
#[inline(always)]
pub fn dacpriv(&self) -> DACPRIV_R {
DACPRIV_R::new(((self.bits >> 18) & 0x01) != 0)
}
#[doc = "Bit 19 - OPAMPPRIV"]
#[inline(always)]
pub fn opamppriv(&self) -> OPAMPPRIV_R {
OPAMPPRIV_R::new(((self.bits >> 19) & 0x01) != 0)
}
#[doc = "Bit 20 - LPTIM1PRIV"]
#[inline(always)]
pub fn lptim1priv(&self) -> LPTIM1PRIV_R {
LPTIM1PRIV_R::new(((self.bits >> 20) & 0x01) != 0)
}
#[doc = "Bit 21 - LPUART1PRIV"]
#[inline(always)]
pub fn lpuart1priv(&self) -> LPUART1PRIV_R {
LPUART1PRIV_R::new(((self.bits >> 21) & 0x01) != 0)
}
#[doc = "Bit 22 - I2C4PRIV"]
#[inline(always)]
pub fn i2c4priv(&self) -> I2C4PRIV_R {
I2C4PRIV_R::new(((self.bits >> 22) & 0x01) != 0)
}
#[doc = "Bit 23 - LPTIM2PRIV"]
#[inline(always)]
pub fn lptim2priv(&self) -> LPTIM2PRIV_R {
LPTIM2PRIV_R::new(((self.bits >> 23) & 0x01) != 0)
}
#[doc = "Bit 24 - LPTIM3PRIV"]
#[inline(always)]
pub fn lptim3priv(&self) -> LPTIM3PRIV_R {
LPTIM3PRIV_R::new(((self.bits >> 24) & 0x01) != 0)
}
#[doc = "Bit 25 - FDCAN1PRIV"]
#[inline(always)]
pub fn fdcan1priv(&self) -> FDCAN1PRIV_R {
FDCAN1PRIV_R::new(((self.bits >> 25) & 0x01) != 0)
}
#[doc = "Bit 26 - USBFSPRIV"]
#[inline(always)]
pub fn usbfspriv(&self) -> USBFSPRIV_R {
USBFSPRIV_R::new(((self.bits >> 26) & 0x01) != 0)
}
#[doc = "Bit 27 - UCPD1PRIV"]
#[inline(always)]
pub fn ucpd1priv(&self) -> UCPD1PRIV_R {
UCPD1PRIV_R::new(((self.bits >> 27) & 0x01) != 0)
}
#[doc = "Bit 28 - VREFBUFPRIV"]
#[inline(always)]
pub fn vrefbufpriv(&self) -> VREFBUFPRIV_R {
VREFBUFPRIV_R::new(((self.bits >> 28) & 0x01) != 0)
}
#[doc = "Bit 29 - COMPPRIV"]
#[inline(always)]
pub fn comppriv(&self) -> COMPPRIV_R {
COMPPRIV_R::new(((self.bits >> 29) & 0x01) != 0)
}
#[doc = "Bit 30 - TIM1PRIV"]
#[inline(always)]
pub fn tim1priv(&self) -> TIM1PRIV_R {
TIM1PRIV_R::new(((self.bits >> 30) & 0x01) != 0)
}
#[doc = "Bit 31 - SPI1PRIV"]
#[inline(always)]
pub fn spi1priv(&self) -> SPI1PRIV_R {
SPI1PRIV_R::new(((self.bits >> 31) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 0 - TIM2PRIV"]
#[inline(always)]
pub fn tim2priv(&mut self) -> TIM2PRIV_W {
TIM2PRIV_W { w: self }
}
#[doc = "Bit 1 - TIM3PRIV"]
#[inline(always)]
pub fn tim3priv(&mut self) -> TIM3PRIV_W {
TIM3PRIV_W { w: self }
}
#[doc = "Bit 2 - TIM4PRIV"]
#[inline(always)]
pub fn tim4priv(&mut self) -> TIM4PRIV_W {
TIM4PRIV_W { w: self }
}
#[doc = "Bit 3 - TIM5PRIV"]
#[inline(always)]
pub fn tim5priv(&mut self) -> TIM5PRIV_W {
TIM5PRIV_W { w: self }
}
#[doc = "Bit 4 - TIM6PRIV"]
#[inline(always)]
pub fn tim6priv(&mut self) -> TIM6PRIV_W {
TIM6PRIV_W { w: self }
}
#[doc = "Bit 5 - TIM7PRIV"]
#[inline(always)]
pub fn tim7priv(&mut self) -> TIM7PRIV_W {
TIM7PRIV_W { w: self }
}
#[doc = "Bit 6 - WWDGPRIV"]
#[inline(always)]
pub fn wwdgpriv(&mut self) -> WWDGPRIV_W {
WWDGPRIV_W { w: self }
}
#[doc = "Bit 7 - IWDGPRIV"]
#[inline(always)]
pub fn iwdgpriv(&mut self) -> IWDGPRIV_W {
IWDGPRIV_W { w: self }
}
#[doc = "Bit 8 - SPI2PRIV"]
#[inline(always)]
pub fn spi2priv(&mut self) -> SPI2PRIV_W {
SPI2PRIV_W { w: self }
}
#[doc = "Bit 9 - SPI3PRIV"]
#[inline(always)]
pub fn spi3priv(&mut self) -> SPI3PRIV_W {
SPI3PRIV_W { w: self }
}
#[doc = "Bit 10 - USART2PRIV"]
#[inline(always)]
pub fn usart2priv(&mut self) -> USART2PRIV_W {
USART2PRIV_W { w: self }
}
#[doc = "Bit 11 - USART3PRIV"]
#[inline(always)]
pub fn usart3priv(&mut self) -> USART3PRIV_W {
USART3PRIV_W { w: self }
}
#[doc = "Bit 12 - UART4PRIV"]
#[inline(always)]
pub fn uart4priv(&mut self) -> UART4PRIV_W {
UART4PRIV_W { w: self }
}
#[doc = "Bit 13 - UART5PRIV"]
#[inline(always)]
pub fn uart5priv(&mut self) -> UART5PRIV_W {
UART5PRIV_W { w: self }
}
#[doc = "Bit 14 - I2C1PRIV"]
#[inline(always)]
pub fn i2c1priv(&mut self) -> I2C1PRIV_W {
I2C1PRIV_W { w: self }
}
#[doc = "Bit 15 - I2C2PRIV"]
#[inline(always)]
pub fn i2c2priv(&mut self) -> I2C2PRIV_W {
I2C2PRIV_W { w: self }
}
#[doc = "Bit 16 - I2C3PRIV"]
#[inline(always)]
pub fn i2c3priv(&mut self) -> I2C3PRIV_W {
I2C3PRIV_W { w: self }
}
#[doc = "Bit 17 - CRSPRIV"]
#[inline(always)]
pub fn crspriv(&mut self) -> CRSPRIV_W {
CRSPRIV_W { w: self }
}
#[doc = "Bit 18 - DACPRIV"]
#[inline(always)]
pub fn dacpriv(&mut self) -> DACPRIV_W {
DACPRIV_W { w: self }
}
#[doc = "Bit 19 - OPAMPPRIV"]
#[inline(always)]
pub fn opamppriv(&mut self) -> OPAMPPRIV_W {
OPAMPPRIV_W { w: self }
}
#[doc = "Bit 20 - LPTIM1PRIV"]
#[inline(always)]
pub fn lptim1priv(&mut self) -> LPTIM1PRIV_W {
LPTIM1PRIV_W { w: self }
}
#[doc = "Bit 21 - LPUART1PRIV"]
#[inline(always)]
pub fn lpuart1priv(&mut self) -> LPUART1PRIV_W {
LPUART1PRIV_W { w: self }
}
#[doc = "Bit 22 - I2C4PRIV"]
#[inline(always)]
pub fn i2c4priv(&mut self) -> I2C4PRIV_W {
I2C4PRIV_W { w: self }
}
#[doc = "Bit 23 - LPTIM2PRIV"]
#[inline(always)]
pub fn lptim2priv(&mut self) -> LPTIM2PRIV_W {
LPTIM2PRIV_W { w: self }
}
#[doc = "Bit 24 - LPTIM3PRIV"]
#[inline(always)]
pub fn lptim3priv(&mut self) -> LPTIM3PRIV_W {
LPTIM3PRIV_W { w: self }
}
#[doc = "Bit 25 - FDCAN1PRIV"]
#[inline(always)]
pub fn fdcan1priv(&mut self) -> FDCAN1PRIV_W {
FDCAN1PRIV_W { w: self }
}
#[doc = "Bit 26 - USBFSPRIV"]
#[inline(always)]
pub fn usbfspriv(&mut self) -> USBFSPRIV_W {
USBFSPRIV_W { w: self }
}
#[doc = "Bit 27 - UCPD1PRIV"]
#[inline(always)]
pub fn ucpd1priv(&mut self) -> UCPD1PRIV_W {
UCPD1PRIV_W { w: self }
}
#[doc = "Bit 28 - VREFBUFPRIV"]
#[inline(always)]
pub fn vrefbufpriv(&mut self) -> VREFBUFPRIV_W {
VREFBUFPRIV_W { w: self }
}
#[doc = "Bit 29 - COMPPRIV"]
#[inline(always)]
pub fn comppriv(&mut self) -> COMPPRIV_W {
COMPPRIV_W { w: self }
}
#[doc = "Bit 30 - TIM1PRIV"]
#[inline(always)]
pub fn tim1priv(&mut self) -> TIM1PRIV_W {
TIM1PRIV_W { w: self }
}
#[doc = "Bit 31 - SPI1PRIV"]
#[inline(always)]
pub fn spi1priv(&mut self) -> SPI1PRIV_W {
SPI1PRIV_W { w: self }
}
}
|
// https://leetcode.com/problems/number-of-steps-to-reduce-a-number-to-zero/submissions/
impl Solution {
pub fn number_of_steps(mut num: i32) -> i32 {
oper(num)
}
}
fn oper(mut num: i32) -> i32 {
match num {
0 => 0,
_ => match num %2 {
0 => 1 + oper(num / 2),
_ => 1 + oper(num - 1)
}
}
} |
use crate::tts::{TtsConstructionError, TtsError, TtsInfo, VoiceDescr};
use reqwest::{RequestBuilder, Url};
use unic_langid::{langid, langids, LanguageIdentifier};
use super::http_tts::HttpsTtsData;
pub struct GttsData();
impl HttpsTtsData for GttsData {
fn make_request_url(&self, voice: &str, input: &str) -> Result<reqwest::Url, TtsError> {
Ok(Url::parse(&google_translate_tts::url(input, voice)).unwrap())
}
fn edit_request(&self, _input: &str, req: reqwest::RequestBuilder) -> RequestBuilder {
const USER_AGENT: &str = "Mozilla/5.0 (Windows NT 10.0; WOW64) \
AppleWebKit/537.36 (KHTML, like Gecko) \
Chrome/47.0.2526.106 Safari/537.36";
req.header("Referer", "http://translate.google.com/")
.header("User-Agent", USER_AGENT)
}
fn get_voice_name(
&self,
lang: &str,
region: &str,
_prefs: &VoiceDescr,
) -> Result<String, TtsConstructionError> {
Ok(format!("{}-{}", lang, region))
}
fn get_info(&self) -> TtsInfo {
TtsInfo {
name: "Google Translate".to_string(),
is_online: true,
}
}
fn get_available_langs(&self) -> Vec<LanguageIdentifier> {
// Note: Google also allows others ("sq", "hy", "bs", "hr", "eo", "mk",
// "sw", "cy"), however, they use what seems to be Espeak, at which point
// you are better off just using espeak yourself
langids!(
"af", "ar", "bn", "bg", "ca", "cs", "da", "de", "en", "et", "el", "fi", "fr", "gu",
"he", "hi", "hu", "is", "id", "it", "iw", "ja", "jv", "kn", "km", "ko", "nl", "lv",
"ms", "ml", "my", "ne", "no", "pl", "pt", "ro", "ru", "sr", "si", "sk", "es", "su",
"sv", "tl", "ta", "te", "th", "tr", "uk", "ur", "vi", "zh-CN", "zh-TW"
)
}
}
|
// use std::io::Error;
// use std::fmt;
fn main() {
type_synonyms_with_type_aliases();
never_type();
sized_trait();
}
fn type_synonyms_with_type_aliases() {
/*
Because Kilometers and i32 are the same type, we can add values of both
types and we can pass Kilometers values to functions that take i32
parameters. However, using this method, we don’t get the type checking
benefits that we get from the newtype pattern discussed earlier.
*/
type Kilometers = i32;
let x: i32 = 5;
let y: Kilometers = 5;
println!("type_synonyms_with_type_aliases: x + y = {}", x + y);
/*
A type alias makes this code more manageable by reducing the repetition.
let f: Box<dyn Fn() + Send + 'static> = Box::new(|| println!("hi"));
fn takes_long_type(f: Box<dyn Fn() + Send + 'static>) {
// --snip--
}
fn returns_long_type() -> Box<dyn Fn() + Send + 'static> {
// --snip--
}
type Thunk = Box<dyn Fn() + Send + 'static>;
let f: Thunk = Box::new(|| println!("hi"));
fn takes_long_type(f: Thunk) {
// --snip--
}
fn returns_long_type() -> Thunk {
// --snip--
}
*/
/*
The Result<..., Error> is repeated a lot. As such, std::io has this type of
alias declaration.
pub trait Write {
fn write(&mut self, buf: &[u8]) -> Result<usize, Error>;
fn flush(&mut self) -> Result<(), Error>;
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>;
fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Error>;
}
Because this declaration is in the std::io module, we can use the fully
qualified alias std::io::Result<T>—that is, a Result<T, E> with the E filled
in as std::io::Error. The Write trait function signatures end up looking
like this:
pub trait Write {
fn write(&mut self, buf: &[u8]) -> Result<usize>;
fn flush(&mut self) -> Result<()>;
fn write_all(&mut self, buf: &[u8]) -> Result<()>;
fn write_fmt(&mut self, fmt: Arguments) -> Result<()>;
}
*/
}
fn never_type() {
/*
Rust has a special type named ! that’s known in type theory lingo as the
empty type because it has no values. We prefer to call it the never type
because it stands in the place of the return type when a function will never
return. Here is an example:
fn bar() -> ! {
// --snip--
}
This code is read as “the function bar returns never.” Functions that return
never are called diverging functions. We can’t create values of the type !
so bar can never possibly return.
continue has a ! value. That is, when Rust computes the type of guess, it
looks at both match arms, the former with a value of u32 and the latter with
a ! value. Because ! can never have a value, Rust decides that the type of
guess is u32.
Expressions of type ! can be coerced into any other type. We’re allowed to
end this match arm with continue because continue doesn’t return a value.
In this code, val has the type T and panic! has the type !, so the result of
the overall match expression is T. This code works because panic! doesn’t
produce a value; it ends the program. In the None case, we won’t be
returning a value from unwrap, so this code is valid.
impl<T> Option<T> {
pub fn unwrap(self) -> T {
match self {
Some(val) => val,
None => panic!("called `Option::unwrap()` on a `None` value"),
}
}
}
One final expression that has the type ! is a loop:
print!("forever ");
loop {
print!("and ever ");
}
*/
}
fn sized_trait() {
/*
To work with DSTs, Rust has a particular trait called the Sized trait to
determine whether or not a type’s size is known at compile time. This trait
is automatically implemented for everything whose size is known at compile
time. In addition, Rust implicitly adds a bound on Sized to every generic
function. That is, a generic function definition like this:
fn generic<T>(t: T) {
// --snip--
}
is actually treated as though we had written this:
fn generic<T: Sized>(t: T) {
// --snip--
}
By default, generic functions will work only on types that have a known size
at compile time. However, you can use the following special syntax to relax
this restriction:
fn generic<T: ?Sized>(t: &T) {
// --snip--
}
*/
} |
use crate::database::{Database, HasArguments, HasStatement, HasStatementCache, HasValueRef};
use crate::mysql::value::{MySqlValue, MySqlValueRef};
use crate::mysql::{
MySqlArguments, MySqlColumn, MySqlConnection, MySqlQueryResult, MySqlRow, MySqlStatement,
MySqlTransactionManager, MySqlTypeInfo,
};
/// MySQL database driver.
#[derive(Debug)]
pub struct MySql;
impl Database for MySql {
type Connection = MySqlConnection;
type TransactionManager = MySqlTransactionManager;
type Row = MySqlRow;
type QueryResult = MySqlQueryResult;
type Column = MySqlColumn;
type TypeInfo = MySqlTypeInfo;
type Value = MySqlValue;
}
impl<'r> HasValueRef<'r> for MySql {
type Database = MySql;
type ValueRef = MySqlValueRef<'r>;
}
impl HasArguments<'_> for MySql {
type Database = MySql;
type Arguments = MySqlArguments;
type ArgumentBuffer = Vec<u8>;
}
impl<'q> HasStatement<'q> for MySql {
type Database = MySql;
type Statement = MySqlStatement<'q>;
}
impl HasStatementCache for MySql {}
|
//
// Main entry point for the wal_acceptor executable
//
use anyhow::Result;
use clap::{App, Arg};
use daemonize::Daemonize;
use log::*;
use std::env;
use std::path::{Path, PathBuf};
use std::thread;
use zenith_utils::logging;
use walkeeper::s3_offload;
use walkeeper::wal_service;
use walkeeper::WalAcceptorConf;
fn main() -> Result<()> {
let arg_matches = App::new("Zenith wal_acceptor")
.about("Store WAL stream to local file system and push it to WAL receivers")
.arg(
Arg::with_name("datadir")
.short("D")
.long("dir")
.takes_value(true)
.help("Path to the WAL acceptor data directory"),
)
.arg(
Arg::with_name("listen")
.short("l")
.long("listen")
.takes_value(true)
.help("listen for incoming connections on ip:port (default: 127.0.0.1:5454)"),
)
.arg(
Arg::with_name("pageserver")
.short("p")
.long("pageserver")
.takes_value(true),
)
.arg(
Arg::with_name("ttl")
.long("ttl")
.takes_value(true)
.help("interval for keeping WAL as walkeeper node, after which them will be uploaded to S3 and removed locally"),
)
.arg(
Arg::with_name("recall")
.long("recall")
.takes_value(true)
.help("Period for requestion pageserver to call for replication"),
)
.arg(
Arg::with_name("daemonize")
.short("d")
.long("daemonize")
.takes_value(false)
.help("Run in the background"),
)
.arg(
Arg::with_name("no-sync")
.short("n")
.long("no-sync")
.takes_value(false)
.help("Do not wait for changes to be written safely to disk"),
)
.get_matches();
let mut conf = WalAcceptorConf {
data_dir: PathBuf::from("./"),
daemonize: false,
no_sync: false,
pageserver_addr: None,
listen_addr: "localhost:5454".to_string(),
ttl: None,
recall_period: None,
pageserver_auth_token: env::var("PAGESERVER_AUTH_TOKEN").ok(),
};
if let Some(dir) = arg_matches.value_of("datadir") {
conf.data_dir = PathBuf::from(dir);
// change into the data directory.
std::env::set_current_dir(&conf.data_dir)?;
}
if arg_matches.is_present("no-sync") {
conf.no_sync = true;
}
if arg_matches.is_present("daemonize") {
conf.daemonize = true;
}
if let Some(addr) = arg_matches.value_of("listen") {
conf.listen_addr = addr.to_owned();
}
if let Some(addr) = arg_matches.value_of("pageserver") {
conf.pageserver_addr = Some(addr.to_owned());
}
if let Some(ttl) = arg_matches.value_of("ttl") {
conf.ttl = Some(humantime::parse_duration(ttl)?);
}
if let Some(recall) = arg_matches.value_of("recall") {
conf.recall_period = Some(humantime::parse_duration(recall)?);
}
start_wal_acceptor(conf)
}
fn start_wal_acceptor(conf: WalAcceptorConf) -> Result<()> {
let log_filename = conf.data_dir.join("wal_acceptor.log");
let (_scope_guard, log_file) = logging::init(log_filename, conf.daemonize)?;
if conf.daemonize {
info!("daemonizing...");
// There should'n be any logging to stdin/stdout. Redirect it to the main log so
// that we will see any accidental manual fprintf's or backtraces.
let stdout = log_file.try_clone().unwrap();
let stderr = log_file;
let daemonize = Daemonize::new()
.pid_file("wal_acceptor.pid")
.working_directory(Path::new("."))
.stdout(stdout)
.stderr(stderr);
match daemonize.start() {
Ok(_) => info!("Success, daemonized"),
Err(e) => error!("Error, {}", e),
}
}
let mut threads = Vec::new();
if conf.ttl.is_some() {
let s3_conf = conf.clone();
let s3_offload_thread = thread::Builder::new()
.name("S3 offload thread".into())
.spawn(|| {
// thread code
s3_offload::thread_main(s3_conf);
})
.unwrap();
threads.push(s3_offload_thread);
}
let wal_acceptor_thread = thread::Builder::new()
.name("WAL acceptor thread".into())
.spawn(|| {
// thread code
let thread_result = wal_service::thread_main(conf);
if let Err(e) = thread_result {
info!("wal_service thread terminated: {}", e);
}
})
.unwrap();
threads.push(wal_acceptor_thread);
for t in threads {
t.join().unwrap()
}
Ok(())
}
|
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Respawning {
pub base_time: f32,
pub time_remaining: Option<f32>,
}
|
#[allow(unused_macros)]
macro_rules! parse_line {
[$( $x:tt : $t:ty ),+] => {
//declare variables
$( let $x: $t; )+
{
use std::str::FromStr;
// read
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).unwrap();
#[allow(deprecated)]
let mut splits = buf.trim_right().split_whitespace();
// assign each variable
$(
$x = splits.next().and_then(|s| <$t>::from_str(s).ok()).unwrap();
)+
// all strs should be used for assignment
assert!(splits.next().is_none());
}
};
}
use std::collections::HashMap;
fn main() {
parse_line![node_count: usize, edge_count: usize];
let connections = {
let mut temp = HashMap::with_capacity(node_count);
for i in 1..node_count + 1 {
temp.insert(i, vec![]);
}
for _ in 0..edge_count {
parse_line![node_label1: usize, node_label2: usize];
temp.get_mut(&node_label1).unwrap().push(node_label2);
temp.get_mut(&node_label2).unwrap().push(node_label1);
}
temp
};
let depths = scan_all_node_minimum_depth(1, &connections);
let mut guides = HashMap::with_capacity(node_count);
search(1, &connections, &depths, &mut guides);
let mut buffer = String::with_capacity(1000000);
for i in 2..node_count + 1 {
if let Some(to) = guides.get(&i) {
buffer.push_str(&format!("{}\n", to));
} else {
println!("No",);
return;
}
}
println!("Yes");
println!("{}", buffer);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Guide<N> {
from: N,
to: N,
}
fn scan_all_node_minimum_depth<N: Copy + Eq + std::hash::Hash>(
root_node: N,
connections: &HashMap<N, Vec<N>>,
) -> HashMap<N, usize> {
let mut depths = HashMap::new();
let mut current_depth = 0;
depths.insert(root_node, current_depth);
let mut scan_target_nodes = match connections.get(&root_node) {
Some(connected_nodes) => connected_nodes.to_vec(),
None => return HashMap::new(),
};
while !scan_target_nodes.is_empty() {
current_depth += 1;
let mut next_targets = vec![];
for target in scan_target_nodes.into_iter() {
if depths.get(&target).is_some() {
continue;
}
depths.insert(target, current_depth);
if let Some(connected_to_target) = connections.get(&target) {
for &next_target in connected_to_target.into_iter() {
next_targets.push(next_target);
}
}
}
scan_target_nodes = next_targets;
}
depths
}
fn search<N: Copy + Eq + std::hash::Hash>(
current_node: N,
connections: &HashMap<N, Vec<N>>,
node_depths: &HashMap<N, usize>,
current_guides: &mut HashMap<N, N>,
) {
for &connected_node in connections[¤t_node]
.iter()
.filter(|n| node_depths[¤t_node] + 1 == node_depths[n])
{
if current_guides.get(&connected_node).is_some() {
continue;
}
current_guides.insert(connected_node, current_node);
search(connected_node, connections, node_depths, current_guides);
}
}
|
use std::sync::Arc;
use crate::config::TableConfig;
use std::path::PathBuf;
use crate::table::{TableSchema, ColumnSchema, ColumnId, ColumnType, PrimaryKeySpec, DetachedRowData, ColumnData, ColumnValue, RowData};
use uuid::Uuid;
use crate::time::{ManualClock, MergeTimestamp, HtClock};
const TEST_DIR: &str = "__test__";
pub fn test_table_config() -> Arc<TableConfig> {
let base_folder = PathBuf::from(TEST_DIR);
match std::fs::create_dir(&base_folder) {
Ok(_) => println!("creating folder {:?}", &base_folder),
Err(_) => {}
}
Arc::new(TableConfig {
base_folder
})
}
pub struct SimpleTableTestSetup {
pub schema: Arc<TableSchema>,
pub clock: ManualClock,
}
impl SimpleTableTestSetup {
pub fn new() -> SimpleTableTestSetup {
SimpleTableTestSetup {
schema: SimpleTableTestSetup::table_schema(),
clock: ManualClock::new(MergeTimestamp::from_ticks(12345)),
}
}
fn table_schema() -> Arc<TableSchema> {
Arc::new(TableSchema::new ("test_table", &Uuid::new_v4(), vec!(
ColumnSchema {
col_id: ColumnId(0),
name: "pk".to_string(),
tpe: ColumnType::BigInt,
pk_spec: PrimaryKeySpec::PartitionKey
},
ColumnSchema {
col_id: ColumnId(1),
name: "text".to_string(),
tpe: ColumnType::Text,
pk_spec: PrimaryKeySpec::Regular
},
ColumnSchema {
col_id: ColumnId(2),
name: "int".to_string(),
tpe: ColumnType::Int,
pk_spec: PrimaryKeySpec::Regular
},
)))
}
pub fn full_row(&self, pk: i64, text: Option<&'static str>, int: Option<i64>) -> DetachedRowData {
DetachedRowData::assemble(&self.schema,
&vec!(
ColumnData::new (ColumnId(0),self.clock.now(),None,Some(ColumnValue::BigInt(pk))),
ColumnData::new (ColumnId(1), self.clock.now(), None, text.map(|t| ColumnValue::Text(t))),
ColumnData::new (ColumnId(2), self.clock.now(), None, int.map(|i| ColumnValue::BigInt(i))),
),
)
}
pub fn partial_row(&self, pk: i64, text: Option<&'static str>) -> DetachedRowData {
DetachedRowData::assemble(&self.schema,
&vec!(
ColumnData::new (ColumnId(0),self.clock.now(),None,Some(ColumnValue::BigInt(pk))),
ColumnData::new (ColumnId(1), self.clock.now(), None, text.map(|t| ColumnValue::Text(t))),
),
)
}
pub fn pk_row(&self, pk: i64) -> DetachedRowData {
DetachedRowData::assemble(&self.schema,
&vec!(ColumnData::new(ColumnId(0), self.clock.now(), None, Some(ColumnValue::BigInt(pk)))))
}
pub fn pk(&self, row: &RowData) -> i64 {
match row.read_col_by_id(ColumnId(0)).unwrap().value.unwrap() {
ColumnValue::BigInt(v) => v,
_ => panic!("no pk value")
}
}
pub fn value<'a>(&self, row: &'a RowData) -> &'a str {
match row.read_col_by_id(ColumnId(1)).unwrap().value.unwrap() {
ColumnValue::Text(v) => v,
_ => panic!("no value")
}
}
} |
use bigneon_db::models::{FeeSchedule, TicketType, TicketTypeStatus};
use bigneon_db::utils::errors::*;
use chrono::NaiveDateTime;
use diesel::PgConnection;
use models::DisplayTicketPricing;
use uuid::Uuid;
#[derive(Debug, Deserialize, PartialEq, Serialize)]
pub struct UserDisplayTicketType {
pub id: Uuid,
pub name: String,
pub status: String,
pub quantity: u32,
pub start_date: NaiveDateTime,
pub end_date: NaiveDateTime,
pub increment: i32,
pub ticket_pricing: Option<DisplayTicketPricing>,
}
impl UserDisplayTicketType {
pub fn from_ticket_type(
ticket_type: &TicketType,
fee_schedule: &FeeSchedule,
conn: &PgConnection,
) -> Result<UserDisplayTicketType, DatabaseError> {
let ticket_type_status = ticket_type.status();
let mut status = ticket_type_status.to_string();
let quantity = ticket_type.remaining_ticket_count(conn)?;
let ticket_pricing = match ticket_type.current_ticket_pricing(conn).optional()? {
Some(ticket_pricing) => Some(DisplayTicketPricing::from_ticket_pricing(
&ticket_pricing,
fee_schedule,
conn,
)?),
None => None,
};
if ticket_type_status == TicketTypeStatus::Published {
if quantity == 0 {
status = TicketTypeStatus::SoldOut.to_string();
} else if ticket_pricing.is_none() {
status = TicketTypeStatus::NoActivePricing.to_string();
}
}
Ok(UserDisplayTicketType {
id: ticket_type.id,
name: ticket_type.name.clone(),
status,
start_date: ticket_type.start_date,
end_date: ticket_type.end_date,
ticket_pricing,
quantity,
increment: ticket_type.increment,
})
}
}
|
use core::mem;
use core::pin::Pin;
use core::ptr;
use futures_core::future::Future;
use futures_core::task::{Context, Poll};
#[must_use = "futures do nothing unless you `.await` or poll them"]
#[derive(Debug)]
pub(crate) enum Chain<Fut1, Fut2, Data> {
First(Fut1, Data),
Second(Fut2),
Empty,
}
impl<Fut1: Unpin, Fut2: Unpin, Data> Unpin for Chain<Fut1, Fut2, Data> {}
impl<Fut1, Fut2, Data> Chain<Fut1, Fut2, Data> {
pub(crate)fn is_terminated(&self) -> bool {
if let Chain::Empty = *self { true } else { false }
}
}
struct UnsafeEmptyOnDrop<Fut1, Fut2, Data>(*mut Chain<Fut1, Fut2, Data>);
impl<Fut1, Fut2, Data> Drop for UnsafeEmptyOnDrop<Fut1, Fut2, Data> {
fn drop(&mut self) {
unsafe {
ptr::write(self.0, Chain::Empty);
}
}
}
impl<Fut1, Fut2, Data> Chain<Fut1, Fut2, Data>
where Fut1: Future,
Fut2: Future,
{
pub(crate) fn new(fut1: Fut1, data: Data) -> Chain<Fut1, Fut2, Data> {
Chain::First(fut1, data)
}
fn take_data(&mut self) -> Data {
unsafe {
let auto_empty = UnsafeEmptyOnDrop(self);
let data = match self {
Chain::First(fut1, data) => {
ptr::drop_in_place(fut1);
ptr::read(data)
}
_ => unreachable!()
};
mem::drop(auto_empty);
data
}
}
pub(crate) fn poll<F>(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
f: F,
) -> Poll<Fut2::Output>
where F: FnOnce(Fut1::Output, Data) -> Fut2,
{
let mut f = Some(f);
// Safe to call `get_unchecked_mut` because we won't move the futures.
let this = unsafe { self.get_unchecked_mut() };
loop {
let output = match this {
Chain::First(fut1, _data) => {
ready!(unsafe { Pin::new_unchecked(fut1) }.poll(cx))
}
Chain::Second(fut2) => {
return unsafe { Pin::new_unchecked(fut2) }.poll(cx);
}
Chain::Empty => unreachable!()
};
let data = Chain::take_data(this); // Drop fut1
let fut2 = (f.take().unwrap())(output, data);
*this = Chain::Second(fut2)
}
}
}
|
use std::fs::File;
use std::io::prelude::*;
const chain: usize = 13;
fn main() -> std::io::Result<()>{
let mut file = File::open("input.txt")?;
let mut contents = String::new();
file.read_to_string(&mut contents)?;
let N = contents.find('\n').expect("no newlines");
let M = contents.matches('\n').count();
let mut grid_raw = vec![0; N * M];
// Vector of 'width' elements slices
let mut grid_base: Vec<_> = grid_raw.as_mut_slice().chunks_mut(N).collect();
// Final 2d array
let grid: &mut [&mut [u64]] = grid_base.as_mut_slice();
for (m, line) in contents.lines().enumerate() {
for (n, character) in line.chars().enumerate() {
grid[m][n] = character.to_digit(10).expect("wtf") as u64;
}
}
let mut candidates : Vec<Option<u64>> = Vec::new();
for m in (0..grid.len()) {
for n in (0..grid[m].len()) {
candidates.push(across(grid, m, n));
candidates.push(down(grid, m, n));
//candidates.push(diagonal(grid, m, n));
//candidates.push(other_diagonal(grid, m, n));
}
}
let largest = candidates.iter().flat_map(|x| x).fold(&u64::min_value(), |a, b| a.max(b));
println!("{:?}", largest);
Ok(())
}
fn across(grid: &mut [&mut [u64]], m: usize, n: usize) -> Option<u64> {
let mut t : Vec<Option<&u64>> = Vec::new();
for i in (0..chain) {
match grid.get(m) {
Some(x) => t.push(x.get(n + i)),
None => t.push(None)
}
}
if t.iter().all(|x| x.is_some()) {
let product = t.iter().flat_map(|x| *x).fold(1 as u64, |a, b| a * b);
return Some(product);
}
return None;
}
fn down(grid: &mut [&mut [u64]], m: usize, n: usize) -> Option<u64> {
let mut t : Vec<Option<&u64>> = Vec::new();
for i in (0..chain) {
match grid.get(m + i) {
Some(x) => t.push(x.get(n)),
None => t.push(None)
}
}
if t.iter().all(|x| x.is_some()) {
let product = t.iter().flat_map(|x| *x).fold(1 as u64, |a, b| a * b);
return Some(product);
}
return None;
}
fn diagonal(grid: &mut [&mut [u64]], m: usize, n: usize) -> Option<u64> {
let mut t : Vec<Option<&u64>> = Vec::new();
for i in (0..chain) {
match grid.get(m + i) {
Some(x) => t.push(x.get(n + i)),
None => t.push(None)
}
}
if t.iter().all(|x| x.is_some()) {
let product = t.iter().flat_map(|x| *x).fold(1 as u64, |a, b| a * b);
return Some(product);
}
return None;
}
fn other_diagonal(grid: &mut [&mut [u64]], m: usize, n: usize) -> Option<u64> {
let mut t : Vec<Option<&u64>> = Vec::new();
for i in (0..chain) {
match grid.get(m.checked_sub(i)?) {
Some(x) => t.push(x.get(n.checked_sub(i)?)),
None => t.push(None)
}
}
if t.iter().all(|x| x.is_some()) {
let product = t.iter().flat_map(|x| *x).fold(1 as u64, |a, b| a * b);
return Some(product);
}
return None;
}
|
use spin::{Mutex, RwLock};
use std::any::Any;
use std::marker::PhantomData;
#[cfg(feature = "sgx")]
use std::prelude::v1::*;
use std::sync::{Arc, Weak};
use async_io::event::{Events, Pollee, Poller};
use async_io::file::{Async, File, SeekFrom};
use async_io::prelude::{Result, *};
use futures::future::BoxFuture;
use futures::prelude::*;
use crate::file::tracker::SeqRdTracker;
use crate::page_cache::{AsFd, Page, PageCache, PageHandle, PageState};
use crate::util::{align_down, align_up};
pub use self::flusher::Flusher;
use io_uring_callback::{Fd, Handle, IoUring};
#[cfg(feature = "sgx")]
use sgx_untrusted_alloc::UntrustedAllocator;
mod flusher;
mod tracker;
/// An instance of file with async APIs.
pub struct AsyncFile<Rt: AsyncFileRt + ?Sized> {
fd: i32,
pos: Mutex<usize>,
len: RwLock<usize>,
can_read: bool,
can_write: bool,
seq_rd_tracker: Mutex<SeqRdTracker>,
pollee: Pollee,
fixed_events: Events,
phantom_data: PhantomData<Rt>,
weak_self: Weak<Self>,
}
/// The runtime support for AsyncFile.
///
/// AsyncFile cannot work on its own: it leverages PageCache to accelerate I/O,
/// needs Flusher to persist data, and eventually depends on IoUring to perform
/// async I/O. This trait provides a common interface for user-implemented runtimes
/// that support AsyncFile.
pub trait AsyncFileRt: Send + Sync + 'static {
/// Returns the io_uring instance.
fn io_uring() -> &'static IoUring;
fn page_cache() -> &'static PageCache;
fn flusher() -> &'static Flusher<Self>;
fn auto_flush();
}
impl<Rt: AsyncFileRt + ?Sized> File for AsyncFile<Rt> {
fn read(&self, buf: &mut [u8]) -> Result<usize> {
let mut pos = self.pos.lock();
let res = self.do_read_at(*pos, buf);
if let Ok(nbytes) = &res {
*pos += *nbytes;
}
res
}
fn write(&self, buf: &[u8]) -> Result<usize> {
let mut pos = self.pos.lock();
let res = self.do_write_at(*pos, buf);
if let Ok(nbytes) = &res {
*pos += *nbytes;
}
res
}
fn seek(&self, seek_pos: SeekFrom) -> Result<usize> {
let mut pos = self.pos.lock();
match seek_pos {
SeekFrom::Start(offset) => {
*pos = offset;
}
SeekFrom::End(offset) => {
let len = self.len.read();
*pos = len
.checked_add(offset)
.ok_or_else(|| errno!(EOVERFLOW, "offset overflow"))?;
}
SeekFrom::Current(offset) => {
let new_pos = if offset >= 0 {
pos.checked_add(offset as usize)
.ok_or_else(|| errno!(EOVERFLOW, "offset overflow"))?
} else {
pos.checked_sub(-offset as usize)
.ok_or_else(|| errno!(EINVAL, "offset underflow"))?
};
*pos = new_pos;
}
}
Ok(*pos)
}
fn read_at(&self, offset: usize, buf: &mut [u8]) -> Result<usize> {
self.do_read_at(offset, buf)
}
fn write_at(&self, offset: usize, buf: &[u8]) -> Result<usize> {
self.do_write_at(offset, buf)
}
fn flush(&self) -> BoxFuture<'_, Result<()>> {
let fd = self.fd;
(async move {
loop {
const FLUSH_BATCH_SIZE: usize = 64;
let num_flushed = Rt::flusher().flush_by_fd(fd, FLUSH_BATCH_SIZE).await;
if num_flushed == 0 {
break;
}
}
let complete_fn = move |retval: i32| assert!(retval == 0);
let io_uring = Rt::io_uring();
let handle = unsafe { io_uring.fsync(Fd(fd), false, complete_fn) };
handle.await;
return Ok(());
})
.boxed()
}
fn poll_by(&self, mask: Events, mut poller: Option<&mut Poller>) -> Events {
// Both the file's and flusher's pollee affects the readiness of
// reads and writes on this file.
let reborrowed_poller = poller.as_mut().map(|p| &mut **p);
self.pollee.poll_by(mask, reborrowed_poller);
let flusher = Rt::flusher();
flusher.pollee().poll_by(mask, poller);
self.fixed_events
}
fn as_any(&self) -> &dyn Any {
self as &dyn Any
}
}
impl<Rt: AsyncFileRt + ?Sized> AsyncFile<Rt> {
/// Open a file at a given path.
///
/// The three arguments have the same meaning as the open syscall.
pub fn open(mut path: String, flags: i32, mode: u32) -> Result<Async<Arc<Self>>> {
let (can_read, can_write) = if flags & libc::O_WRONLY != 0 {
(false, true)
} else if flags & libc::O_RDWR != 0 {
(true, true)
} else {
// libc::O_RDONLY = 0
(true, false)
};
let fd = unsafe {
let c_path = std::ffi::CString::new(path).unwrap();
let c_path_ptr = c_path.as_bytes_with_nul().as_ptr() as _;
let flags = if flags & libc::O_WRONLY != 0 {
(flags & !libc::O_WRONLY) | libc::O_RDWR
} else {
flags
};
#[cfg(not(feature = "sgx"))]
let fd = libc::open(c_path_ptr, flags, mode);
#[cfg(feature = "sgx")]
let fd = libc::ocall::open64(c_path_ptr, flags, mode as i32);
fd
};
if fd < 0 {
return_errno!(Errno::from(libc_errno() as u32), "libc::open error");
}
#[cfg(not(feature = "sgx"))]
let len = unsafe { libc::lseek(fd, 0, libc::SEEK_END) };
#[cfg(feature = "sgx")]
let len = unsafe { libc::ocall::lseek(fd, 0, libc::SEEK_END) };
if len < 0 {
return_errno!(Errno::from(libc_errno() as u32), "libc::lseek error");
}
// A regular file is always readable (or writable) if it is open for
// read or write.
let fixed_events = {
let mut events = Events::empty();
if can_read {
events |= Events::IN;
}
if can_write {
events |= Events::OUT;
}
events
};
let new_self = (Self {
fd,
pos: Mutex::new(0),
len: RwLock::new(len as usize),
can_read,
can_write,
seq_rd_tracker: Mutex::new(SeqRdTracker::new()),
pollee: Pollee::new(fixed_events),
fixed_events,
phantom_data: PhantomData,
weak_self: Weak::default(),
})
.wrap();
Ok(new_self)
}
fn wrap(self) -> Async<Arc<Self>> {
// Create an Arc, make a Weak from it, then put it into the struct.
// It's a little tricky.
let arc = Arc::new(self);
let weak = Arc::downgrade(&arc);
let ptr = Arc::into_raw(arc) as *mut Self;
unsafe {
(*ptr).weak_self = weak;
Async::new(Arc::from_raw(ptr))
}
}
fn do_read_at(&self, offset: usize, buf: &mut [u8]) -> Result<usize> {
if !self.can_read {
return_errno!(EBADF, "not open for read");
}
if buf.len() == 0 {
return Ok(0);
}
self.check_args(offset, buf.len())?;
let file_len = *self.len.read();
// For reads beyond the end of the file
if offset >= file_len {
// EOF
return Ok(0);
}
// For reads within the bound of the file
let file_remaining = file_len - offset;
let buf_len = buf.len().min(file_remaining);
let buf = &mut buf[..buf_len];
// Use tracker to determine if the new read is sequential and how much data to prefetch.
let mut tracker = self.seq_rd_tracker.try_lock();
let new_read = tracker
.as_mut()
.map(|tracker| tracker.track(offset, buf.len()));
let prefetch_len = {
let prefetch_len = new_read.as_ref().map_or(0, |seq_rd| seq_rd.prefetch_size());
let max_prefetch_len = file_remaining - buf.len();
prefetch_len.min(max_prefetch_len)
};
// Fetch the data to the page cache and copy the data of the first ready pages
// in the page cache to the output buffer.
let mut read_nbytes = 0;
self.fetch_pages(offset, buf_len, prefetch_len, |page_handle: &PageHandle| {
let page_slice = unsafe { page_handle.page().as_slice() };
let inner_offset = offset + read_nbytes - page_handle.offset();
let page_remain = Page::size() - inner_offset;
let buf_remain = buf_len - read_nbytes;
let copy_size = buf_remain.min(page_remain);
let src_buf = &page_slice[inner_offset..inner_offset + copy_size];
let target_buf = &mut buf[read_nbytes..read_nbytes + copy_size];
target_buf.copy_from_slice(src_buf);
read_nbytes += copy_size;
});
if read_nbytes > 0 {
new_read.map(|new_read| new_read.complete(read_nbytes));
Ok(read_nbytes)
} else {
return_errno!(EAGAIN, "try again later");
}
}
// Fetch and prefetch pages.
//
// The first pages in the fetch range [offset, offset + len) that are ready to read are passed
// to a closure so that the caller can access the data in these pages. Note that the state of the
// page is locked while the closure is being executed.
//
// The pages that are within the range [offset, offset + len + prefetch_len] will be fetched into
// the page cache, if they are not present in the page cache.
//
// The procedure works in two phases. The first phase is fetching, in which we iterate
// the first pages that are ready to read. These pages are passed to the access closure
// one-by-one. Upon reaching the first page that cannot be read or beyond the fetching
// range [offset, offset + len), we transit to the second phase: prefetching. In this
// phase, we will try out our best to bring the pages into the page cache,
// issueing async reads if needed.
fn fetch_pages(
&self,
offset: usize,
len: usize,
prefetch_len: usize,
mut access_fn: impl FnMut(&PageHandle),
) {
// If the first stage, the value is true; if the second stage, false.
let mut should_call_access_fn = true;
// Prepare for async read that fetches multiple consecutive pages
let mut consecutive_pages = Vec::new();
// Enter the loop that fetches and prefetches pages.
let arc_self = self.clone_arc();
let page_cache = Rt::page_cache();
let page_begin = align_down(offset, Page::size());
let page_end = align_up(offset + len + prefetch_len, Page::size());
let fetch_end = align_up(offset + len, Page::size());
for page_offset in (page_begin..page_end).step_by(Page::size()) {
if should_call_access_fn && page_offset >= fetch_end {
should_call_access_fn = false;
}
let page = match page_cache.acquire(&arc_self, page_offset) {
Some(page) => page,
None => break,
};
let mut state = page.state();
if should_call_access_fn {
// The fetching phase
match *state {
PageState::UpToDate | PageState::Dirty | PageState::Flushing => {
// Invoke the access function
(access_fn)(&page);
drop(state);
page_cache.release(page);
}
PageState::Uninit => {
// Start prefetching
*state = PageState::Fetching;
drop(state);
consecutive_pages.push(page);
// Transit to the prefetching phase
should_call_access_fn = false;
}
PageState::Fetching => {
// We do nothing here
drop(state);
page_cache.release(page);
// Transit to the prefetching phase
should_call_access_fn = false;
}
}
} else {
// The prefetching phase
match *state {
PageState::Uninit => {
// Add one more page to prefetch
*state = PageState::Fetching;
drop(state);
consecutive_pages.push(page);
}
PageState::UpToDate
| PageState::Dirty
| PageState::Flushing
| PageState::Fetching => {
drop(state);
page_cache.release(page);
// When reaching the end of consecutive pages, start the I/O
if consecutive_pages.len() > 0 {
self.fetch_consecutive_pages(consecutive_pages);
consecutive_pages = Vec::new();
}
}
}
}
}
// When reaching the end of consecutive pages, start the I/O
if consecutive_pages.len() > 0 {
self.fetch_consecutive_pages(consecutive_pages);
}
}
fn fetch_consecutive_pages(&self, consecutive_pages: Vec<PageHandle>) {
debug_assert!(!consecutive_pages.is_empty());
debug_assert!(consecutive_pages.windows(2).all(|two_pages| {
let (p0, p1) = (&two_pages[0], &two_pages[1]);
p0.offset() + Page::size() == p1.offset()
}));
debug_assert!(consecutive_pages
.iter()
.all(|page| { *page.state() == PageState::Fetching }));
let first_offset = consecutive_pages[0].offset();
let self_ = self.clone_arc();
let iovecs = Box::new(
consecutive_pages
.iter()
.map(|page_handle| libc::iovec {
iov_base: page_handle.page().as_mut_ptr() as _,
iov_len: Page::size(),
})
.collect::<Vec<libc::iovec>>(),
);
#[cfg(not(feature = "sgx"))]
let (iovecs_ptr, iovecs_len) = ((*iovecs).as_ptr(), (*iovecs).len());
#[cfg(feature = "sgx")]
let (iovecs_ptr, iovecs_len, allocator, iovecs_ptr_u64, t_iovecs_ptr_u64) = {
let iovecs_len = (*iovecs).len();
let t_iovecs_ptr = (*iovecs).as_ptr();
let iovecs_size = iovecs_len * core::mem::size_of::<libc::iovec>();
let allocator = UntrustedAllocator::new(iovecs_size, 8).unwrap();
let iovecs_ptr = allocator.as_mut_ptr() as *mut libc::iovec;
unsafe {
std::ptr::copy_nonoverlapping(t_iovecs_ptr, iovecs_ptr, iovecs_len);
}
(
iovecs_ptr,
iovecs_len,
allocator,
iovecs_ptr as u64,
t_iovecs_ptr as u64,
)
};
struct IovecsBox(Box<Vec<libc::iovec>>);
unsafe impl Send for IovecsBox {}
let iovecs_box = IovecsBox(iovecs);
let handle_store: Arc<Mutex<Option<Handle>>> = Arc::new(Mutex::new(None));
let handle_store2 = handle_store.clone();
let callback = move |retval| {
let page_cache = Rt::page_cache();
let read_nbytes = if retval >= 0 { retval } else { 0 } as usize;
for page in consecutive_pages {
let page_offset = page.offset();
debug_assert!(page_offset >= first_offset);
// For a partial read, fill zeros or in the remaining part of the page.
// TODO: are there partial reads that should not fill zeros?
let page_valid_nbytes = if first_offset + read_nbytes > page_offset {
(first_offset + read_nbytes - page_offset).min(Page::size())
} else {
0
};
if page_valid_nbytes < Page::size() {
let page_slice = unsafe { page.page().as_slice_mut() };
page_slice[page_valid_nbytes..].fill(0);
}
// Update page state
{
let mut state = page.state();
debug_assert!(*state == PageState::Fetching);
*state = PageState::UpToDate;
}
page_cache.release(page);
}
self_.pollee.add_events(Events::IN | Events::OUT);
#[cfg(feature = "sgx")]
drop(allocator);
drop(iovecs_box);
drop(handle_store);
};
let io_uring = Rt::io_uring();
let handle = unsafe {
io_uring.readv(
Fd(self.fd),
iovecs_ptr,
iovecs_len as u32,
first_offset as i64,
0,
callback,
)
};
let mut guard = handle_store2.lock();
guard.replace(handle);
}
fn do_write_at(&self, offset: usize, buf: &[u8]) -> Result<usize> {
if !self.can_write {
return_errno!(EBADF, "not open for write");
}
if buf.len() == 0 {
return Ok(0);
}
self.check_args(offset, buf.len())?;
let mut new_dirty_pages = false;
let mut write_nbytes = 0;
let arc_self = self.clone_arc();
let page_cache = Rt::page_cache();
let page_begin = align_down(offset, Page::size());
let page_end = align_up(offset + buf.len(), Page::size());
for page_offset in (page_begin..page_end).step_by(Page::size()) {
let page_handle = match page_cache.acquire(&arc_self, page_offset) {
Some(page_handle) => page_handle,
None => break,
};
let inner_offset = offset + write_nbytes - page_offset;
let copy_size = {
let page_remain = Page::size() - inner_offset;
let buf_remain = buf.len() - write_nbytes;
buf_remain.min(page_remain)
};
let to_write_full_page = copy_size == Page::size();
let mut do_write = || {
let page_slice = unsafe { page_handle.page().as_slice_mut() };
let src_buf = &buf[write_nbytes..write_nbytes + copy_size];
let dst_buf = &mut page_slice[inner_offset..inner_offset + copy_size];
dst_buf.copy_from_slice(src_buf);
write_nbytes += copy_size;
};
let mut state = page_handle.state();
match *state {
PageState::UpToDate => {
(do_write)();
*state = PageState::Dirty;
drop(state);
page_cache.release(page_handle);
new_dirty_pages = true;
}
PageState::Dirty => {
(do_write)();
drop(state);
page_cache.release(page_handle);
}
PageState::Uninit if to_write_full_page => {
(do_write)();
*state = PageState::Dirty;
drop(state);
page_cache.release(page_handle);
new_dirty_pages = true;
}
PageState::Uninit => {
*state = PageState::Fetching;
drop(state);
self.fetch_consecutive_pages(vec![page_handle]);
break;
}
PageState::Fetching | PageState::Flushing => {
// We do nothing here
drop(state);
page_cache.release(page_handle);
break;
}
}
}
if new_dirty_pages {
Rt::auto_flush();
}
if write_nbytes > 0 {
// Update file length if necessary
let mut file_len = self.len.write();
if offset + write_nbytes > *file_len {
*file_len = offset + write_nbytes;
}
Ok(write_nbytes)
} else {
return_errno!(EAGAIN, "try again later");
}
}
fn check_args(&self, offset: usize, buf_len: usize) -> Result<()> {
// Prevent the return length (i32) from overflow
if buf_len > i32::max_value() as usize {
return_errno!(EINVAL, "buffer is tool large");
}
// Prevent the offset calculation from overflow
if offset.checked_add(buf_len).is_none() {
return_errno!(EFBIG, "offset or buffer is too large");
}
Ok(())
}
pub fn clone_arc(&self) -> Arc<Self> {
self.weak_self.upgrade().unwrap()
}
pub(crate) fn pollee(&self) -> &Pollee {
&self.pollee
}
}
impl<Rt: AsyncFileRt + ?Sized> AsFd for AsyncFile<Rt> {
fn as_fd(&self) -> i32 {
self.fd
}
}
impl<Rt: AsyncFileRt + ?Sized> Drop for AsyncFile<Rt> {
fn drop(&mut self) {
unsafe {
#[cfg(not(feature = "sgx"))]
libc::close(self.fd);
#[cfg(feature = "sgx")]
libc::ocall::close(self.fd);
}
}
}
impl<Rt: AsyncFileRt + ?Sized> std::fmt::Debug for AsyncFile<Rt> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("AsyncFile")
.field("fd", &self.fd)
.field("pollee", self.pollee())
.finish()
}
}
#[cfg(not(feature = "sgx"))]
fn libc_errno() -> i32 {
unsafe {
*(libc::__errno_location())
// *(libc::__error())
}
}
#[cfg(feature = "sgx")]
fn libc_errno() -> i32 {
libc::errno()
}
#[cfg(test)]
mod tests {
use test::Bencher;
use super::*;
use crate::tests::Runtime;
#[bench]
fn write_first_page(b: &mut Bencher) {
let path = "write_first_page.data";
let file = {
let path = path.to_string();
let flags = libc::O_WRONLY | libc::O_CREAT | libc::O_TRUNC;
let mode = libc::S_IRUSR | libc::S_IWUSR;
AsyncFile::<Runtime>::open(path.clone(), flags, mode).unwrap()
};
let mut input_buf = Vec::with_capacity(4096);
input_buf.resize(input_buf.capacity(), 0);
b.iter(|| {
let nbytes = file.file().write_at(0, &input_buf).unwrap();
assert!(nbytes == input_buf.len());
})
}
#[bench]
fn write_first_page_linux(b: &mut Bencher) {
// It is important that the path is NULL-terminated
let path = "write_first_page_linux.data\0";
let fd = {
let path = path.as_ptr() as _;
let flags = libc::O_WRONLY | libc::O_CREAT | libc::O_TRUNC;
let mode = libc::S_IRUSR | libc::S_IWUSR;
let ret = unsafe { libc::open(path, flags, mode) };
assert!(ret >= 0);
ret
};
let mut buf = Vec::with_capacity(4096);
buf.resize(buf.capacity(), 0);
let buf_ptr = buf.as_ptr() as _;
let buf_len = buf.len();
b.iter(|| {
let ret = unsafe { libc::pwrite(fd, buf_ptr, buf_len, 0) };
assert!(ret as usize == buf.len());
})
}
#[bench]
fn read_first_page(b: &mut Bencher) {
let path = "read_first_page.data";
let file = {
let path = path.to_string();
let flags = libc::O_RDWR | libc::O_CREAT | libc::O_TRUNC;
let mode = libc::S_IRUSR | libc::S_IWUSR;
AsyncFile::<Runtime>::open(path.clone(), flags, mode).unwrap()
};
let mut buf = Vec::with_capacity(4096);
buf.resize(buf.capacity(), 0);
file.file().write_at(0, &buf).unwrap();
b.iter(|| {
let nbytes = file.file().read_at(0, &mut buf).unwrap();
assert!(nbytes == buf.len());
})
}
#[bench]
fn read_first_page_linux(b: &mut Bencher) {
// It is important that the path is NULL-terminated
let path = "read_first_page_linux.data\0";
let fd = {
let path = path.as_ptr() as _;
let flags = libc::O_RDWR | libc::O_CREAT | libc::O_TRUNC;
let mode = libc::S_IRUSR | libc::S_IWUSR;
let ret = unsafe { libc::open(path, flags, mode) };
assert!(ret >= 0);
ret
};
let mut buf = Vec::with_capacity(4096);
buf.resize(buf.capacity(), 0);
let buf_ptr = buf.as_mut_ptr() as _;
let buf_len = buf.len();
assert!(unsafe { libc::pwrite(fd, buf_ptr, buf_len, 0) } as usize == buf_len);
b.iter(|| {
let ret = unsafe { libc::pread(fd, buf_ptr as _, buf_len, 0) };
assert!(ret as usize == buf_len);
})
}
}
|
extern crate addr2line;
extern crate fallible_iterator;
extern crate memmap;
extern crate object;
extern crate unwind;
use fallible_iterator::FallibleIterator;
use unwind::{DwarfUnwinder, Unwinder};
use addr2line::Context;
// ugly hack :(
#[inline(never)]
fn no_tailcall_please() {
print!("")
}
#[test]
fn correctness() {
test_frame_1();
no_tailcall_please();
}
#[inline(never)]
fn test_frame_1() {
test_frame_2();
no_tailcall_please();
}
#[inline(never)]
fn test_frame_2() {
test_frame_3();
no_tailcall_please();
}
static REFERENCE: &'static [&'static str] = &[
"_ZN6unwind8{{impl}}14trace<closure>E",
"_ZN11correctness12test_frame_3E",
"_ZN11correctness12test_frame_2E",
"_ZN11correctness12test_frame_1E",
"_ZN11correctness11correctnessE",
];
#[inline(never)]
fn test_frame_3() {
DwarfUnwinder::default().trace(|frames| {
let map = memmap::Mmap::open_path("/proc/self/exe", memmap::Protection::Read).unwrap();
let file = &object::File::parse(unsafe { map.as_slice() }).unwrap();
let ctx = Context::new(file).unwrap().parse_functions().unwrap();
let mut trace: Vec<String> = Vec::new();
while let Some(frame) = frames.next().unwrap() {
let ip = frames.registers()[16].unwrap() - 1 - frame.object_base;
let mut frames = ctx.query(ip).unwrap();
while let Some(frame) = frames.next().unwrap() {
trace.push(frame.function.unwrap().raw_name().unwrap().into_owned());
}
}
assert_eq!(&trace[..REFERENCE.len()], REFERENCE);
});
no_tailcall_please();
}
#[test]
fn zero_sequence() {
let map = memmap::Mmap::open_path("/proc/self/exe", memmap::Protection::Read).unwrap();
let file = &object::File::parse(unsafe { map.as_slice() }).unwrap();
let ctx = Context::new(file).unwrap();
for probe in 0..10 {
assert!(ctx.find_location(probe).unwrap().is_none());
}
}
#[test]
fn zero_function() {
let map = memmap::Mmap::open_path("/proc/self/exe", memmap::Protection::Read).unwrap();
let file = &object::File::parse(unsafe { map.as_slice() }).unwrap();
let ctx = Context::new(file).unwrap().parse_functions().unwrap();
for probe in 0..10 {
assert!(ctx.query(probe).unwrap().next().unwrap().is_none());
}
}
|
extern crate toml;
extern crate clap;
use std::{
str,
fs::{File, create_dir_all, remove_dir_all},
io::{Result, Read, Write},
process::Command
};
use serde::{Serialize, Deserialize};
use toml::value::Array;
use clap::{Arg, App, SubCommand};
#[derive(Debug, Serialize, Deserialize)]
struct Config {
package: ConfigPackage,
dependencies: ConfigDependencies
}
#[derive(Debug, Serialize, Deserialize)]
struct ConfigPackage {
name: String,
author: Option<String>
}
#[derive(Debug, Serialize, Deserialize)]
struct ConfigDependencies {
link: Array
}
impl Config {
fn new(package: ConfigPackage, dependencies: ConfigDependencies) -> Result<Config> {
let conf = Config { package, dependencies };
Ok(conf)
}
fn from(path: &str) -> Result<Config> {
let mut file = File::open(path)?;
let mut buffer = String::new();
file.read_to_string(&mut buffer)?;
let conf: Config = toml::from_str(buffer.as_str()).expect("Invalid toml file");
Ok(conf)
}
fn to_string(&self) -> Result<String> {
let string = toml::to_string(&self).expect("Failed to convert to toml");
Ok(string)
}
}
fn new(name: &str) -> Result<Config> {
let git = Command::new("git").arg("config").arg("-l").output()?.stdout;
let git_info: Vec<&str> = str::from_utf8(&git).unwrap_or_default().lines().collect();
let mut author_info: (&str, &str) = ("", "");
for i in git_info {
if i.starts_with("user.name=") { author_info.0 = &i[10..]; }
else if i.starts_with("user.email=") { author_info.1 = &i[11..]; }
}
let author = if author_info.0 == "" && author_info.1 == "" {
None
} else {
Some(format!("{} <{}>", author_info.0, author_info.1))
};
let conf = Config::new(
ConfigPackage {
name: String::from(name), author
}, ConfigDependencies {
link: vec![]
})?;
create_dir_all(format!("{}/src", name).as_str())?;
create_dir_all(format!("{}/test", name).as_str())?;
create_dir_all(format!("{}/target", name).as_str())?;
let mut file = File::create(format!("{}/Cog.toml", name).as_str())?;
file.write_all(conf.to_string()?.as_bytes())?;
let mut file = File::create(format!("{}/src/main.c", name).as_str())?;
file.write_all("#include <stdio.h>\n\nint main()\n{\n\tprintf(\"Hello, World!\\n\");\n\treturn 0;\n}\n".as_bytes())?;
let mut file = File::create(format!("{}/test/main.c", name).as_str())?;
file.write_all("#include <assert.h>\n\nint main()\n{\n\tassert(1 && \"This will pass\");\n\tassert(0 && \"This won't pass\");\n\treturn 0;\n}\n".as_bytes())?;
Command::new("git")
.current_dir(name)
.arg("init")
.arg("-q")
.spawn()?;
Ok(conf)
}
fn build() -> Result<()> {
let conf = read("Cog.toml")?;
create_dir_all("target/debug")?;
let mut cc = Command::new("gcc");
cc.arg("-o").arg(format!("target/debug/{}", conf.package.name).as_str());
cc.arg("-Wall").arg("-ansi").arg("-DNDEBUG");
cc.arg("src/main.c");
for i in conf.dependencies.link {
cc.arg(i.as_str().expect(format!("Link {:#?} is not a String", i).as_str()));
}
cc.spawn()?.wait()?;
Ok(())
}
fn release(run_after: bool) -> Result<()> {
let conf = read("Cog.toml")?;
create_dir_all("target/release")?;
Command::new("gcc")
.arg("-o").arg(format!("target/release/{}", conf.package.name).as_str())
.arg("-Wall").arg("-ansi").arg("-DNDEBUG").arg("-O3")
.arg("-Isrc/**/")
.arg("src/main.c")
.spawn()?.wait()?;
let test_status = test()?;
if run_after && test_status {
Command::new(format!("target/release/{}", conf.package.name).as_str()).spawn()?.wait()?;
}
Ok(())
}
fn run() -> Result<()> {
let conf = read("Cog.toml")?;
build()?;
Command::new(format!("target/debug/{}", conf.package.name).as_str()).spawn()?.wait()?;
Ok(())
}
fn clean() -> Result<()> {
remove_dir_all("target")?;
Ok(())
}
fn test() -> Result<bool> {
let conf = read("Cog.toml")?;
create_dir_all("target/test")?;
Command::new("gcc")
.arg("-o").arg(format!("target/test/{}", conf.package.name).as_str())
.arg("-Wall").arg("-ansi")
.arg("-Isrc/**/")
.arg("test/main.c")
.spawn()?.wait()?;
let exit_status = Command::new(format!("target/test/{}", conf.package.name).as_str()).spawn()?.wait()?.success();
Ok(exit_status)
}
fn read(path: &str) -> Result<Config> {
let conf = Config::from(path)?;
Ok(conf)
}
fn main() {
let matches = App::new("Cog")
.version("1.0")
.author("Gabriel Pucinelli <pucinelli@dext.studio>")
.about("Based on Rust's Cargo, Cog creates a structured c project")
.alias("help")
.subcommand(SubCommand::with_name("new")
.about("Creates a new c project")
.arg(Arg::with_name("NAME")
.help("Name of the project")
.required(true)
)
)
.subcommand(SubCommand::with_name("build")
.about("Builds a c project with a Cog.toml file")
)
.subcommand(SubCommand::with_name("run")
.about("Builds and runs a c project with a Cog.toml file")
)
.subcommand(SubCommand::with_name("clean")
.about("Cleans the target directory and its content")
)
.subcommand(SubCommand::with_name("release")
.about("Builds a c project, tests it and if it succeeds, builds a release version with optimizations turned on")
.arg(Arg::with_name("RUN_AFTER")
.help("Determines if will run the project after releasing it (Y/n)")
)
)
.subcommand(SubCommand::with_name("test")
.about("Tests a c project with a Cog.toml file")
)
.subcommand(SubCommand::with_name("read")
.about("Reads a Cog.toml file")
.arg(Arg::with_name("PATH")
.help("Path to the Cog.toml file")
)
).get_matches();
match matches.subcommand() {
("new", Some(sub_m)) => {
match sub_m.value_of("NAME") {
Some(v) => { new(v).expect(format!("Could not create a workspace for {}", v).as_str()); },
_ => {},
}
},
("release", Some(sub_m)) => {
match sub_m.value_of("RUN_AFTER") {
Some(v) => release(v == "Y" || v == "y").expect("Release failed"),
_ => release(false).expect("Release failed"),
}
},
("read", Some(sub_m)) => {
println!("{:#?}", match sub_m.value_of("PATH") {
Some(v) => read(v).expect(format!("Unable to read {} as a valid Cog.toml file", v).as_str()),
_ => read("Cog.toml").expect("There is not a Cog.toml file in this directory"),
});
},
_ => {
if matches.is_present("build") {
build().expect("Failed to build project");
} else if matches.is_present("run") {
run().expect("Failed to run project");
} else if matches.is_present("test") {
test().expect("Failed to test project");
} else if matches.is_present("clean") {
clean().expect("Failed to clean target directory");
} else {
let cog_bin = std::env::args().nth(0).expect("Failed to get process arguments");
Command::new(cog_bin).arg("help").spawn().expect("Failed to find cog binary");
}
},
}
}
|
//! Utilities to report test results to users
mod color;
mod diff;
pub use color::Palette;
pub(crate) use color::Style;
pub use color::Styled;
pub use diff::write_diff;
|
// Copyright 2021 Datafuse Labs.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::alloc::handle_alloc_error;
use std::alloc::Allocator;
use std::alloc::Layout;
use std::mem::MaybeUninit;
use std::ops::Deref;
use std::ops::DerefMut;
use std::ptr::null_mut;
use std::ptr::NonNull;
/// # Safety
///
/// Any foreign type shouldn't implement this trait.
pub unsafe trait Container
where Self: Deref<Target = [Self::T]> + DerefMut
{
type T;
type A: Allocator;
fn len(&self) -> usize;
fn heap_bytes(&self) -> usize;
unsafe fn new_zeroed(len: usize, allocator: Self::A) -> Self;
unsafe fn grow_zeroed(&mut self, new_len: usize);
}
#[derive(Debug)]
pub struct HeapContainer<T, A: Allocator>(Box<[T], A>);
impl<T, A: Allocator> Deref for HeapContainer<T, A> {
type Target = [T];
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<T, A: Allocator> DerefMut for HeapContainer<T, A> {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
unsafe impl<T, A: Allocator> Container for HeapContainer<T, A> {
type T = T;
type A = A;
#[inline(always)]
fn len(&self) -> usize {
self.as_ref().len()
}
fn heap_bytes(&self) -> usize {
Layout::array::<T>(self.0.len()).unwrap().size()
}
unsafe fn new_zeroed(len: usize, allocator: Self::A) -> Self {
Self(Box::new_zeroed_slice_in(len, allocator).assume_init())
}
unsafe fn grow_zeroed(&mut self, new_len: usize) {
debug_assert!(self.len() <= new_len);
let old_layout = Layout::array::<T>(self.len()).unwrap();
let new_layout = Layout::array::<T>(new_len).unwrap();
let old_box = std::ptr::read(&self.0);
let (old_raw, allocator) = Box::into_raw_with_allocator(old_box);
let old_ptr = NonNull::new(old_raw).unwrap().cast();
let grow_res = allocator.grow_zeroed(old_ptr, old_layout, new_layout);
match grow_res {
Err(_) => handle_alloc_error(new_layout),
Ok(new_ptr) => {
let new_raw = std::ptr::slice_from_raw_parts_mut(new_ptr.cast().as_ptr(), new_len);
let new_box = Box::from_raw_in(new_raw, allocator);
std::ptr::write(self, Self(new_box));
}
}
}
}
pub struct StackContainer<T, const N: usize, A: Allocator> {
allocator: A,
ptr: *mut T,
len: usize,
array: [MaybeUninit<T>; N],
}
impl<T, const N: usize, A: Allocator> Deref for StackContainer<T, N, A> {
type Target = [T];
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe {
std::slice::from_raw_parts(
if self.ptr.is_null() {
self.array.as_ptr() as *const _
} else {
self.ptr
},
self.len,
)
}
}
}
impl<T, const N: usize, A: Allocator> DerefMut for StackContainer<T, N, A> {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
unsafe {
std::slice::from_raw_parts_mut(
if self.ptr.is_null() {
self.array.as_mut_ptr() as *mut _
} else {
self.ptr
},
self.len,
)
}
}
}
unsafe impl<T, const N: usize, A: Allocator + Clone> Container for StackContainer<T, N, A> {
type T = T;
type A = A;
#[inline(always)]
fn len(&self) -> usize {
self.len
}
fn heap_bytes(&self) -> usize {
match self.len <= N {
true => 0,
false if self.ptr.is_null() => 0,
false => Layout::array::<T>(self.len).unwrap().size(),
}
}
unsafe fn new_zeroed(len: usize, allocator: Self::A) -> Self {
if len <= N {
Self {
allocator,
ptr: null_mut(),
len,
array: std::array::from_fn(|_| MaybeUninit::zeroed()),
}
} else {
let layout = Layout::array::<T>(len).unwrap();
let allocated_bytes = allocator.allocate_zeroed(layout);
match allocated_bytes {
Err(_) => handle_alloc_error(layout),
Ok(allocated_bytes) => Self {
len,
allocator,
ptr: allocated_bytes.cast().as_ptr(),
array: std::array::from_fn(|_| MaybeUninit::uninit()),
},
}
}
}
unsafe fn grow_zeroed(&mut self, new_len: usize) {
debug_assert!(self.len <= new_len);
if new_len <= N {
self.len = new_len;
} else if self.ptr.is_null() {
let layout = Layout::array::<T>(new_len).unwrap();
let allocated_bytes = self.allocator.allocate_zeroed(layout);
match allocated_bytes {
Err(_) => handle_alloc_error(layout),
Ok(allocated_bytes) => {
self.ptr = allocated_bytes.cast().as_ptr();
std::ptr::copy_nonoverlapping(
self.array.as_ptr() as *mut _,
self.ptr,
self.len,
);
self.len = new_len;
}
};
} else {
let old_layout = Layout::array::<T>(self.len).unwrap();
let new_layout = Layout::array::<T>(new_len).unwrap();
let old_ptr = NonNull::new_unchecked(self.ptr).cast();
let reallocated_bytes = self.allocator.grow_zeroed(old_ptr, old_layout, new_layout);
match reallocated_bytes {
Err(_) => handle_alloc_error(new_layout),
Ok(reallocated_bytes) => {
self.ptr = reallocated_bytes.cast::<T>().as_ptr();
self.len = new_len;
}
};
}
}
}
impl<T, const N: usize, A: Allocator> Drop for StackContainer<T, N, A> {
fn drop(&mut self) {
if !self.ptr.is_null() {
unsafe {
self.allocator.deallocate(
NonNull::new(self.ptr).unwrap().cast(),
Layout::array::<T>(self.len).unwrap(),
);
}
}
}
}
|
// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//! Some stuff used by rustc that doesn't have many dependencies
//!
//! Originally extracted from rustc::back, which was nominally the
//! compiler 'backend', though LLVM is rustc's backend, so rustc_target
//! is really just odds-and-ends relating to code gen and linking.
//! This crate mostly exists to make rustc smaller, so we might put
//! more 'stuff' here in the future. It does not have a dependency on
//! LLVM.
#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
html_root_url = "https://doc.rust-lang.org/nightly/")]
#![feature(box_syntax)]
#![feature(const_fn)]
#![cfg_attr(not(stage0), feature(nll))]
#![feature(slice_patterns)]
#[macro_use]
extern crate bitflags;
extern crate serialize;
#[macro_use] extern crate log;
extern crate serialize as rustc_serialize; // used by deriving
// See librustc_cratesio_shim/Cargo.toml for a comment explaining this.
#[allow(unused_extern_crates)]
extern crate rustc_cratesio_shim;
pub mod abi;
pub mod spec;
|
use std::process::exit;
use getopts::Options;
use openssl::ssl::{SslMethod, SslContext, SslFiletype, SslVerifyMode};
use mqtt3::{LastWill, SubscribeTopic, QoS, Protocol};
use super::command::{Command, SubscribeCommand, PublishCommand};
pub struct CLI {
program: String,
command: String,
arguments: Vec<String>
}
impl CLI {
pub fn new<C: IntoIterator<Item=String>>(args: C) -> CLI {
let mut args: Vec<String> = args.into_iter().collect();
let program = args.remove(0);
let command = if args.len() < 1 {
"help".to_string()
} else {
args.remove(0)
};
CLI {
program: program,
command: command,
arguments: args
}
}
pub fn parse(&self) -> Box<Command> {
match self.command.as_str() {
"subscribe" | "sub" => Box::new(self.subscribe_parse()),
"publish" | "pub" => Box::new(self.publish_parse()),
"help" | _ => {
self.print_usage();
exit(0);
}
}
}
pub fn publish_parse(&self) -> PublishCommand {
let default = PublishCommand::default();
let mut opts = Options::new();
opts.optopt("t", "", "The topic name which payload data is published.", "topic");
opts.optopt("m", "", "Message payload to send", "message");
opts.optopt("f", "", "Send file as the payload", "file");
opts.optopt("q", "", "Quality of service level", "qos");
opts.optflag("r", "", "Message should be retained");
opts.optopt("a", "", "Address to connect to. Defaults to localhost", "address");
opts.optopt("p", "", "Port to connect to. Defaults to 1883", "port");
opts.optopt("k", "", "Keep alive the link with the server then try to send ping request. Defaults to 60", "seconds");
opts.optopt("i", "", "Specifies a client id", "client_id");
opts.optopt("u", "", "Specifies a username with which to authenticate to", "username");
opts.optopt("P", "", "Specifies a password with which to authenticate to", "password");
opts.optopt("v", "", "MQTT protocol version. Can be 3.1 or 3.1.1", "version");
opts.optflag("d", "", "Show debug messages");
opts.optopt("", "tls", "Enables TLS and sets protocol version. Can be tlsv1, tlsv1.1, tlsv1.2", "");
opts.optopt("", "cafile", "Specifies the file that contains trusted CA certificates.", "file");
//opts.optopt("", "capath", "TODO", "path");
opts.optopt("", "key", "Path to private key", "path");
opts.optopt("", "cert", "Path to certificate", "path");
opts.optflag("", "no-verify", "Disables client cert requests");
opts.optflag("h", "help", "Display this message");
let matches = match opts.parse(&self.arguments[..]) {
Ok(m) => { m }
Err(f) => {
self.cli_error(f.to_string());
}
};
if matches.opt_present("h") {
self.publish_print_usage(opts);
exit(0);
};
let topic = matches.opt_str("t").unwrap_or_else(|| self.cli_error("Please set the topic name"));
let message = matches.opt_str("m");
let file = matches.opt_str("f");
if message.is_some() && file.is_some() {
self.cli_error("Shouldn't set both message and file together");
};
let qos = matches.opt_str("q").map_or(QoS::AtLeastOnce, |s| self.parse_qos(s));
let retain = matches.opt_present("r");
let address = matches.opt_str("a").unwrap_or(default.address);
let port = if matches.opt_present("p") {
match matches.opt_str("p").unwrap().parse::<u16>() {
Ok(v) => v,
Err(_) => {
self.cli_error("port format error");
}
}
} else {
default.port
};
let client_id = matches.opt_str("i");
let username = matches.opt_str("u");
let password = matches.opt_str("P");
let debug = matches.opt_present("d");
let keep_alive = if matches.opt_present("k") {
match matches.opt_str("k").unwrap().parse::<u16>() {
Ok(v) => v,
Err(_) => {
self.cli_error("keep alive format error");
}
}
} else {
default.keep_alive
};
let protocol = if matches.opt_present("v") {
match matches.opt_str("v").unwrap().as_ref() {
"3.1" => Protocol::MQIsdp(3),
"3.1.1" => Protocol::MQTT(4),
_ => {
self.cli_error("unsupported protocol version");
}
}
} else {
default.protocol
};
let cafile = matches.opt_str("cafile");
let key = matches.opt_str("key");
let cert = matches.opt_str("cert");
let ssl_method = if matches.opt_present("tls") {
match matches.opt_str("tls").unwrap().as_ref() {
// FIXME: TLS versions are ignored here
"1" => Some(SslMethod::tls()),
"1.1" => Some(SslMethod::tls()),
"1.2" => Some(SslMethod::tls()),
_ => {
self.cli_error("unsupported TLS version")
}
}
} else {
None
};
let verify_mode = if matches.opt_present("no-verify") {
SslVerifyMode::from_bits_truncate(0)
} else {
SslVerifyMode::from_bits_truncate(1)
};
let ssl_context = ssl_method.map(|ssl| {
let mut context = SslContext::builder(ssl).unwrap();
context.set_verify(verify_mode);
if let Some(ref cafile_path) = cafile {
context.set_ca_file(cafile_path).unwrap();
}
if let Some(ref key_path) = key {
context.set_private_key_file(key_path, SslFiletype::PEM).unwrap();
}
if let Some(ref cert_path) = cert {
context.set_certificate_file(cert_path, SslFiletype::PEM).unwrap();
}
context.build()
});
PublishCommand {
topic: topic,
message: message,
file: file,
qos: qos,
retain: retain,
// Connection
address: address,
port: port,
keep_alive: keep_alive,
// preferences
debug: debug,
protocol: protocol,
// Authorization
client_id: client_id,
username: username,
password: password,
// SSL/TLS option
ssl_context: ssl_context
}
}
pub fn subscribe_parse(&self) -> SubscribeCommand {
let default = SubscribeCommand::default();
let mut opts = Options::new();
opts.optopt("a", "", "Address to connect to. Defaults to localhost", "address");
opts.optopt("p", "", "Port to connect to. Defaults to 1883", "port");
opts.optopt("q", "", "Maximum quality of service level", "qos");
opts.optopt("k", "", "Keep alive the link with the server then try to send ping request. Defaults to 60", "seconds");
opts.optflag("r", "", "Reconnect automatically if connection was broken.");
opts.optopt("i", "", "Specifies a client id", "client_id");
opts.optopt("u", "", "Specifies a username with which to authenticate to", "username");
opts.optopt("P", "", "Specifies a password with which to authenticate to", "password");
//opts.optopt("l", "", "Log messages to specified file", "log_file");
opts.optopt("v", "", "MQTT protocol version. Can be 3.1 or 3.1.1", "version");
opts.optflag("c", "", "Set 'clean session' flag");
opts.optflag("d", "", "Show debug messages");
opts.optflag("s", "", "Prevent to show a connection messages");
//opts.optopt("f", "", "Piece of topic path to filter out incomming messages. Can be repeated.", "filter");
//opts.optflag("", "no-retain", "Hide retained messages");
//opts.optopt("", "limit", "Disconnect after `limit` received messages.", "");
opts.optopt("", "will-message", "Message for the client Will", "");
opts.optopt("", "will-topic", "Topic for the client Will", "");
opts.optopt("", "will-qos", "QoS level for the client Will", "");
opts.optopt("", "will-retain", "Make the client Will retained", "");
opts.optopt("", "tls", "Enables TLS and sets protocol version. Can be tlsv1, tlsv1.1, tlsv1.2", "");
opts.optopt("", "cafile", "Specifies the file that contains trusted CA certificates.", "file");
//opts.optopt("", "capath", "TODO", "path");
opts.optopt("", "key", "Path to private key", "path");
opts.optopt("", "cert", "Path to certificate", "path");
opts.optflag("", "no-verify", "Disables client cert requests");
opts.optflag("h", "help", "Display this message");
let matches = match opts.parse(&self.arguments[..]) {
Ok(m) => { m }
Err(f) => {
self.cli_error(f.to_string());
}
};
if matches.opt_present("h") {
self.subscribe_print_usage(opts);
exit(0);
};
let address = matches.opt_str("a").unwrap_or(default.address);
let port = if matches.opt_present("p") {
match matches.opt_str("p").unwrap().parse::<u16>() {
Ok(v) => v,
Err(_) => {
self.cli_error("port format error");
}
}
} else {
default.port
};
let client_id = matches.opt_str("i");
let clean_session = matches.opt_present("c");
let username = matches.opt_str("u");
let password = matches.opt_str("P");
let topic_filters = Vec::new(); // TODO: matches.opt_strs("f");
let limit = None; /*TODO: if matches.opt_present("limit") {
match matches.opt_str("limit").unwrap().parse::<u32>() {
Ok(v) => Some(v),
Err(_) => {
self.cli_error("limit format error");
}
}
} else {
None
};*/
let will_topic = matches.opt_str("will-topic");
let will_message = matches.opt_str("will-message");
let will_qos = matches.opt_str("will-qos");
let will_retain = matches.opt_present("will-retain");
let debug = matches.opt_present("d");
let silence = matches.opt_present("s");
let keep_alive = if matches.opt_present("k") {
match matches.opt_str("k").unwrap().parse::<u16>() {
Ok(v) => v,
Err(_) => {
self.cli_error("keep alive format error");
}
}
} else {
default.keep_alive
};
let reconnect = matches.opt_present("r");
let protocol = if matches.opt_present("v") {
match matches.opt_str("v").unwrap().as_ref() {
"3.1" => Protocol::MQIsdp(3),
"3.1.1" => Protocol::MQTT(4),
_ => {
self.cli_error("unsupported protocol version");
}
}
} else {
default.protocol
};
let log_file = None; // TODO: matches.opt_str("l");
let last_will = if will_topic.is_some() && will_message.is_some() {
Some(LastWill {
topic: will_topic.unwrap(),
message: will_message.unwrap(),
qos: will_qos.map_or(QoS::AtMostOnce, |s| self.parse_qos(s)),
retain: will_retain
})
} else {
if !will_topic.is_none() || !will_topic.is_none() {
self.cli_error("both will-topic and will-message required");
};
None
};
let cafile = matches.opt_str("cafile");
let key = matches.opt_str("key");
let cert = matches.opt_str("cert");
let ssl_method = if matches.opt_present("tls") {
match matches.opt_str("tls").unwrap().as_ref() {
// FIXME: TLS versions are ignored here
"1" => Some(SslMethod::tls()),
"1.1" => Some(SslMethod::tls()),
"1.2" => Some(SslMethod::tls()),
_ => {
self.cli_error("unsupported TLS version")
}
}
} else {
None
};
let verify_mode = if matches.opt_present("no-verify") {
SslVerifyMode::from_bits_truncate(0)
} else {
SslVerifyMode::from_bits_truncate(1)
};
let ssl_context = ssl_method.map(|ssl| {
let mut context = SslContext::builder(ssl).unwrap();
context.set_verify(verify_mode);
if let Some(ref cafile_path) = cafile {
context.set_ca_file(cafile_path).unwrap();
}
if let Some(ref key_path) = key {
context.set_private_key_file(key_path, SslFiletype::PEM).unwrap();
}
if let Some(ref cert_path) = cert {
context.set_certificate_file(cert_path, SslFiletype::PEM).unwrap();
}
context.build()
});
let retain = false; //TODO: !matches.opt_present("no-retain");
let qos = matches.opt_str("q").map_or(QoS::ExactlyOnce, |s| self.parse_qos(s));
let topics = if !matches.free.is_empty() {
matches.free.iter().map(|topic| SubscribeTopic { topic_path: topic.clone(), qos: qos} ).collect()
} else {
default.topics.iter().map(|topic| SubscribeTopic { topic_path: topic.topic_path.clone(), qos: qos} ).collect()
};
SubscribeCommand {
topics: topics,
address: address,
port: port,
clean_session: clean_session,
last_will: last_will,
log_file: log_file,
debug: debug,
silence: silence,
keep_alive: keep_alive,
reconnect: reconnect,
protocol: protocol,
client_id: client_id,
username: username,
password: password,
limit: limit,
retain: retain,
topic_filters: topic_filters,
ssl_context: ssl_context
}
}
fn print_usage(&self) {
let mut brief = "mqttc is a simple MQTT client that provides to publish message or subscribe to topics.\n\n".to_string();
brief = brief + format!("Usage:\n {} command\n {} --help\n\n", self.program, self.program).as_str();
brief = brief + "Commands:\n";
brief = brief + " publish/pub \tPublish message to a topic\n";
brief = brief + " subscribe/sub \tSubscribe to topics\n\n";
print!("{}", brief);
}
pub fn publish_print_usage(&self, opts: Options) {
let brief = format!("Usage: {} publish [OPTIONS]", self.program);
print!("{}", opts.usage(&brief));
}
pub fn subscribe_print_usage(&self, opts: Options) {
let brief = format!("Usage: {} subscribe [OPTIONS] [TOPICS...]", self.program);
print!("{}", opts.usage(&brief));
}
fn parse_qos(&self, s: String) -> QoS {
match s.parse::<u8>() {
Ok(v) => {
match QoS::from_u8(v) {
Ok(qos) => qos,
Err(_) => {
self.cli_error("unsupported qos value");
}
}
},
Err(_) => {
self.cli_error("qos format error");
}
}
}
fn cli_error<M: AsRef<str>>(&self, msg: M) -> ! {
println!("{}: {}", self.program, msg.as_ref());
exit(64); // command line usage error
}
}
|
// Copyright 2020-2021 the Deno authors. All rights reserved. MIT license.
use crate::lexer::{lex, MediaType, TokenOrComment};
use std::convert::TryFrom;
use swc_ecmascript::parser::token::{Token, Word};
pub trait Colorize {
fn colorize(self) -> String;
}
impl Colorize for markdown::Block {
fn colorize(self) -> String {
use markdown::Block::*;
match self {
Header(spans, 1) => {
let style = ansi_term::Style::new()
.bold()
.underline()
.italic()
.fg(ansi_term::Color::Purple);
style.paint(spans.colorize()).to_string().linebreak()
}
Header(spans, 2 | 3) => {
let style = ansi_term::Style::new()
.bold()
.underline()
.fg(ansi_term::Color::Purple);
style.paint(spans.colorize()).to_string().linebreak()
}
Header(spans, 4) => {
let style = ansi_term::Style::new().bold().fg(ansi_term::Color::Purple);
style.paint(spans.colorize()).to_string().linebreak()
}
Header(spans, _level) => {
let style = ansi_term::Style::new().fg(ansi_term::Color::Purple);
style.paint(spans.colorize()).to_string().linebreak()
}
Paragraph(spans) => spans.colorize().linebreak(),
Blockquote(blocks) => {
let style = ansi_term::Style::new().dimmed();
style.paint(blocks.colorize()).to_string().linebreak()
}
CodeBlock(Some(info), content) => {
if let Ok(media_type) = MediaType::try_from(info.as_str()) {
let mut v = Vec::new();
for line in content.split('\n') {
// Ref: https://github.com/denoland/deno/blob/a0c0daac24c496e49e7c0abaae12f34723785a7d/cli/tools/repl.rs#L251-L298
let mut out_line = String::from(line);
for item in lex(line, media_type) {
let offset = out_line.len() - line.len();
let span = item.span_as_range();
out_line.replace_range(
span.start + offset..span.end + offset,
&match item.inner {
TokenOrComment::Token(token) => match token {
Token::Str { .. }
| Token::Template { .. }
| Token::BackQuote => {
ansi_term::Color::Green.paint(&line[span]).to_string()
}
Token::Regex(_, _) => {
ansi_term::Color::Red.paint(&line[span]).to_string()
}
Token::Num(_) | Token::BigInt(_) => {
ansi_term::Color::Yellow.paint(&line[span]).to_string()
}
Token::Word(word) => match word {
Word::True | Word::False | Word::Null => {
ansi_term::Color::Yellow.paint(&line[span]).to_string()
}
Word::Keyword(_) => {
ansi_term::Color::Cyan.paint(&line[span]).to_string()
}
Word::Ident(ident) => {
if ident == *"undefined" {
ansi_term::Color::Fixed(8)
.paint(&line[span])
.to_string()
} else if ident == *"Infinity" || ident == *"NaN" {
ansi_term::Color::Yellow
.paint(&line[span])
.to_string()
} else if matches!(
ident.as_ref(),
"async" | "of" | "enum" | "type" | "interface"
) {
ansi_term::Color::Cyan.paint(&line[span]).to_string()
} else {
line[span].to_string()
}
}
},
_ => line[span].to_string(),
},
TokenOrComment::Comment { .. } => {
ansi_term::Color::Fixed(8).paint(&line[span]).to_string()
}
},
);
}
v.push(out_line.indent(4));
}
v.join("\n").linebreak()
} else {
content
.split('\n')
.map(|line| line.indent(4))
.join_by("\n")
.linebreak()
}
}
CodeBlock(None, content) => content
.split('\n')
.map(|line| line.indent(4))
.join_by("\n")
.linebreak(),
OrderedList(list_items, _list_type) => list_items
.into_iter()
.enumerate()
.map(|(idx, li)| format!("{}. {}", idx, li.colorize()).indent(2))
.join_by("\n")
.linebreak(),
UnorderedList(list_items) => list_items
.into_iter()
.map(|li| format!("• {}", li.colorize()).indent(2))
.join_by("\n")
.linebreak(),
Raw(content) => content.linebreak(),
Hr => ansi_term::Color::Fixed(8)
.paint("-".repeat(80))
.to_string()
.linebreak(),
}
}
}
impl Colorize for Vec<markdown::Block> {
fn colorize(self) -> String {
self.into_iter().map(Colorize::colorize).join_by("\n")
}
}
impl Colorize for markdown::Span {
fn colorize(self) -> String {
use markdown::Span::*;
match self {
Break => "\n".to_string(),
Text(text) => text,
Code(code) => ansi_term::Color::Green.paint(code).to_string(),
Link(label, url, _title) => {
format!("[{label}]({url})", label = label, url = url)
}
Image(alt, url, _title) => {
format!("", alt = alt, url = url)
}
Emphasis(spans) => {
let style = ansi_term::Style::new().italic();
style.paint(spans.colorize()).to_string()
}
Strong(spans) => {
let style = ansi_term::Style::new().bold();
style.paint(spans.colorize()).to_string()
}
}
}
}
impl Colorize for Vec<markdown::Span> {
fn colorize(self) -> String {
self.into_iter().map(Colorize::colorize).join_by("")
}
}
impl Colorize for markdown::ListItem {
fn colorize(self) -> String {
use markdown::ListItem::*;
match self {
Simple(spans) => spans.colorize(),
Paragraph(blocks) => blocks.colorize(),
}
}
}
trait Linebreak {
fn linebreak(self) -> String;
}
impl Linebreak for String {
fn linebreak(self) -> String {
format!("{}\n", self)
}
}
trait Indent {
fn indent(self, width: usize) -> String;
}
impl Indent for String {
fn indent(self, width: usize) -> String {
format!("{}{}", " ".repeat(width), self)
}
}
impl Indent for &str {
fn indent(self, width: usize) -> String {
format!("{}{}", " ".repeat(width), self)
}
}
trait JoinBy {
fn join_by(self, sep: &str) -> String;
}
impl<I> JoinBy for I
where
I: Iterator<Item = String>,
{
fn join_by(self, sep: &str) -> String {
self.collect::<Vec<_>>().join(sep)
}
}
|
pub const INPUT: &str = include_str!("../input.txt");
pub enum Instruction {
Noop,
Add(i32),
}
pub fn parse_input(input: &str) -> Vec<Instruction> {
input
.lines()
.map(|line| {
if line.starts_with('a') {
Instruction::Add(line[5..].parse().unwrap())
} else {
Instruction::Noop
}
})
.collect()
}
pub fn solve(instructions: &[Instruction]) -> (i32, String) {
const CYCLES: [i32; 6] = [20, 60, 100, 140, 180, 220];
let mut sum = 0;
let mut display = String::new();
let mut sprite_position = 1;
let mut display_position = 0;
let mut stored_add = None;
let mut instruction_iter = instructions.iter().peekable();
for cycle in 1.. {
if instruction_iter.peek().is_none() {
break;
}
if CYCLES.contains(&cycle) {
sum += sprite_position * cycle;
}
if display_position == 40 {
display.push('\n');
display_position = 0;
}
if (display_position - sprite_position).abs() <= 1 {
display.push('#');
} else {
display.push('.');
}
display_position += 1;
match stored_add.take() {
Some(v) => sprite_position += v,
None => match instruction_iter.next() {
Some(Instruction::Noop) => {}
Some(Instruction::Add(v)) => {
stored_add = Some(*v);
}
None => unreachable!(),
},
}
}
(sum, display)
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_solve() {
let instructions = parse_input(INPUT);
let (part_one, part_two) = solve(&instructions);
assert_eq!(part_one, 15680);
assert_eq!(
part_two,
"####.####.###..####.#..#..##..#..#.###..\n\
...#.#....#..#.#....#..#.#..#.#..#.#..#.\n\
..#..###..###..###..####.#....#..#.#..#.\n\
.#...#....#..#.#....#..#.#.##.#..#.###..\n\
#....#....#..#.#....#..#.#..#.#..#.#....\n\
####.#....###..#....#..#..###..##..#...."
);
}
}
|
use crate::SystemDataFetch;
use spatialos_sdk::worker::commands::{
CreateEntityRequest, DeleteEntityRequest, EntityQueryRequest, ReserveEntityIdsRequest,
};
use spatialos_sdk::worker::connection::{Connection, WorkerConnection};
use spatialos_sdk::worker::entity::Entity as WorkerEntity;
use spatialos_sdk::worker::op::{
CreateEntityResponseOp, DeleteEntityResponseOp, EntityQueryResponseOp, QueryResponse,
ReserveEntityIdsResponseOp, ReservedEntityIdRange, StatusCode,
};
use spatialos_sdk::worker::query::EntityQuery;
use spatialos_sdk::worker::EntityId as WorkerEntityId;
use spatialos_sdk::worker::RequestId;
use specs::prelude::{Resources, SystemData, Write};
use std::collections::HashMap;
pub type SystemCommandSender<'a> = Write<'a, SystemCommandSenderRes>;
type SystemCommandResult<T> = Result<T, StatusCode<T>>;
type IntermediateCallback<O> = Box<FnOnce(&Resources, O) + Send + Sync>;
pub struct SystemCommandSenderRes {
reserve_entity_ids_callbacks: HashMap<
RequestId<ReserveEntityIdsRequest>,
IntermediateCallback<ReserveEntityIdsResponseOp>,
>,
buffered_reserve_entity_ids_requests:
Vec<(u32, IntermediateCallback<ReserveEntityIdsResponseOp>)>,
create_entity_callbacks:
HashMap<RequestId<CreateEntityRequest>, IntermediateCallback<CreateEntityResponseOp>>,
buffered_create_entity_requests: Vec<(
NoAccessContainer<WorkerEntity>,
Option<WorkerEntityId>,
IntermediateCallback<CreateEntityResponseOp>,
)>,
delete_entity_callbacks:
HashMap<RequestId<DeleteEntityRequest>, IntermediateCallback<DeleteEntityResponseOp>>,
buffered_delete_entity_requests:
Vec<(WorkerEntityId, IntermediateCallback<DeleteEntityResponseOp>)>,
entity_query_callbacks:
HashMap<RequestId<EntityQueryRequest>, IntermediateCallback<EntityQueryResponseOp>>,
buffered_entity_query_requests: Vec<(EntityQuery, IntermediateCallback<EntityQueryResponseOp>)>,
}
// TODO expose parameters like timeout
impl SystemCommandSenderRes {
pub fn reserve_entity_ids<F>(&mut self, number: u32, callback: F)
where
F: 'static
+ FnOnce(SystemCommandResult<ReservedEntityIdRange>, SystemDataFetch)
+ Send
+ Sync,
{
self.buffered_reserve_entity_ids_requests.push((
number,
Box::new(|res, response_op| {
callback(
SystemCommandSenderRes::status_code_to_result(response_op.status_code),
SystemDataFetch::new(res),
);
}),
));
}
pub fn create_entity<F>(
&mut self,
entity: WorkerEntity,
reserved_entity_id: Option<WorkerEntityId>,
callback: F,
) where
F: 'static + FnOnce(SystemCommandResult<WorkerEntityId>, SystemDataFetch) + Send + Sync,
{
self.buffered_create_entity_requests.push((
NoAccessContainer::new(entity),
reserved_entity_id,
Box::new(|res, response_op| {
callback(
SystemCommandSenderRes::status_code_to_result(response_op.status_code),
SystemDataFetch::new(res),
);
}),
));
}
pub fn delete_entity<F>(&mut self, entity_id: WorkerEntityId, callback: F)
where
F: 'static + FnOnce(SystemCommandResult<()>, SystemDataFetch) + Send + Sync,
{
self.buffered_delete_entity_requests.push((
entity_id,
Box::new(|res, response_op| {
callback(
SystemCommandSenderRes::status_code_to_result(response_op.status_code),
SystemDataFetch::new(res),
);
}),
));
}
pub fn entity_query<F>(&mut self, query: EntityQuery, callback: F)
where
F: 'static + FnOnce(SystemCommandResult<QueryResponse>, SystemDataFetch) + Send + Sync,
{
self.buffered_entity_query_requests.push((
query,
Box::new(|res, response_op| {
callback(
SystemCommandSenderRes::status_code_to_result(response_op.status_code),
SystemDataFetch::new(res),
);
}),
));
}
pub(crate) fn got_reserve_entity_ids_response(
res: &Resources,
response_op: ReserveEntityIdsResponseOp,
) {
let callback = {
SystemCommandSender::fetch(res)
.reserve_entity_ids_callbacks
.remove(&response_op.request_id)
};
match callback {
Some(callback) => callback(res, response_op),
None => println!("Unknown request ID: {:?}", response_op.request_id),
}
}
pub(crate) fn got_create_entity_response(res: &Resources, response_op: CreateEntityResponseOp) {
let callback = {
SystemCommandSender::fetch(res)
.create_entity_callbacks
.remove(&response_op.request_id)
};
match callback {
Some(callback) => callback(res, response_op),
None => println!("Unknown request ID: {:?}", response_op.request_id),
}
}
pub(crate) fn got_delete_entity_response(res: &Resources, response_op: DeleteEntityResponseOp) {
let callback = {
SystemCommandSender::fetch(res)
.delete_entity_callbacks
.remove(&response_op.request_id)
};
match callback {
Some(callback) => callback(res, response_op),
None => println!("Unknown request ID: {:?}", response_op.request_id),
}
}
pub(crate) fn got_entity_query_response(res: &Resources, response_op: EntityQueryResponseOp) {
let callback = {
SystemCommandSender::fetch(res)
.entity_query_callbacks
.remove(&response_op.request_id)
};
match callback {
Some(callback) => callback(res, response_op),
None => println!("Unknown request ID: {:?}", response_op.request_id),
}
}
pub(crate) fn flush_requests(&mut self, connection: &mut WorkerConnection) {
for (number, callback) in self.buffered_reserve_entity_ids_requests.drain(..) {
let request_id = connection.send_reserve_entity_ids_request(
ReserveEntityIdsRequest(number),
Default::default(),
);
self.reserve_entity_ids_callbacks
.insert(request_id, callback);
}
for (entity, entity_id, callback) in self.buffered_create_entity_requests.drain(..) {
let request_id = connection.send_create_entity_request(
entity.get_data(),
entity_id,
Default::default(),
);
self.create_entity_callbacks.insert(request_id, callback);
}
for (entity_id, callback) in self.buffered_delete_entity_requests.drain(..) {
let request_id = connection
.send_delete_entity_request(DeleteEntityRequest(entity_id), Default::default());
self.delete_entity_callbacks.insert(request_id, callback);
}
for (query, callback) in self.buffered_entity_query_requests.drain(..) {
let request_id =
connection.send_entity_query_request(EntityQueryRequest(query), Default::default());
self.entity_query_callbacks.insert(request_id, callback);
}
}
fn status_code_to_result<T>(status_code: StatusCode<T>) -> Result<T, StatusCode<T>> {
match status_code {
StatusCode::Success(response) => Ok(response),
other => Err(other),
}
}
}
impl Default for SystemCommandSenderRes {
fn default() -> Self {
SystemCommandSenderRes {
reserve_entity_ids_callbacks: HashMap::new(),
buffered_reserve_entity_ids_requests: Vec::new(),
create_entity_callbacks: HashMap::new(),
buffered_create_entity_requests: Vec::new(),
delete_entity_callbacks: HashMap::new(),
buffered_delete_entity_requests: Vec::new(),
entity_query_callbacks: HashMap::new(),
buffered_entity_query_requests: Vec::new(),
}
}
}
struct NoAccessContainer<T> {
data: T,
}
impl<T> NoAccessContainer<T> {
fn new(data: T) -> NoAccessContainer<T> {
NoAccessContainer { data }
}
fn get_data(self) -> T {
self.data
}
}
// This is safe as the data inside cannot be accessed.
unsafe impl<T> Send for NoAccessContainer<T> {}
unsafe impl<T> Sync for NoAccessContainer<T> {}
#[test]
fn delete_entity_request_should_work() {
use spatialos_sdk::worker::EntityId as WorkerEntityId;
use specs::prelude::{System, World};
let mut world = World::new();
struct Sys;
impl<'a> System<'a> for Sys {
type SystemData = SystemCommandSender<'a>;
fn run(&mut self, _sys: Self::SystemData) {}
}
<Sys as System>::SystemData::setup(&mut world.res);
{
let mut system_command_sender = <Sys as System>::SystemData::fetch(&world.res);
system_command_sender.delete_entity(WorkerEntityId::new(5), |result, system_data| {
let system_command_sender = system_data.fetch::<Sys>();
assert_eq!(
0,
system_command_sender.buffered_delete_entity_requests.len()
);
assert!(result.is_ok());
});
}
{
let mut requests = {
<Sys as System>::SystemData::fetch(&world.res)
.buffered_delete_entity_requests
.drain(..)
.collect::<Vec<_>>()
};
for (_entity_id, callback) in requests.drain(..) {
<Sys as System>::SystemData::fetch(&world.res)
.delete_entity_callbacks
.insert(RequestId::new(1), callback);
}
}
SystemCommandSenderRes::got_delete_entity_response(
&world.res,
DeleteEntityResponseOp {
request_id: RequestId::new(1),
entity_id: WorkerEntityId::new(5),
status_code: StatusCode::Success(()),
},
);
}
|
//! The following is derived from Rust's
//! library/std/src/os/windows/io/socket.rs
//! at revision
//! 4f9b394c8a24803e57ba892fa00e539742ebafc0.
//!
//! All code in this file is licensed MIT or Apache 2.0 at your option.
use super::raw::*;
use crate::backend::c;
use crate::backend::fd::LibcFd as LibcSocket;
use core::fmt;
use core::marker::PhantomData;
use core::mem::forget;
/// A borrowed socket.
///
/// This has a lifetime parameter to tie it to the lifetime of something that
/// owns the socket.
///
/// This uses `repr(transparent)` and has the representation of a host socket,
/// so it can be used in FFI in places where a socket is passed as an argument,
/// it is not captured or consumed, and it never has the value
/// `INVALID_SOCKET`.
///
/// This type's `.to_owned()` implementation returns another `BorrowedSocket`
/// rather than an `OwnedSocket`. It just makes a trivial copy of the raw
/// socket, which is then borrowed under the same lifetime.
#[derive(Copy, Clone)]
#[repr(transparent)]
#[cfg_attr(staged_api, rustc_layout_scalar_valid_range_start(0))]
// This is -2, in two's complement. -1 is `INVALID_SOCKET`.
#[cfg_attr(
all(staged_api, target_pointer_width = "32"),
rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FE)
)]
#[cfg_attr(
all(staged_api, target_pointer_width = "64"),
rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FF_FF_FF_FF_FE)
)]
#[cfg_attr(staged_api, rustc_nonnull_optimization_guaranteed)]
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
pub struct BorrowedSocket<'socket> {
socket: RawSocket,
_phantom: PhantomData<&'socket OwnedSocket>,
}
/// An owned socket.
///
/// This closes the socket on drop.
///
/// This uses `repr(transparent)` and has the representation of a host socket,
/// so it can be used in FFI in places where a socket is passed as a consumed
/// argument or returned as an owned value, and it never has the value
/// `INVALID_SOCKET`.
#[repr(transparent)]
#[cfg_attr(staged_api, rustc_layout_scalar_valid_range_start(0))]
// This is -2, in two's complement. -1 is `INVALID_SOCKET`.
#[cfg_attr(
all(staged_api, target_pointer_width = "32"),
rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FE)
)]
#[cfg_attr(
all(staged_api, target_pointer_width = "64"),
rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FF_FF_FF_FF_FE)
)]
#[cfg_attr(staged_api, rustc_nonnull_optimization_guaranteed)]
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
pub struct OwnedSocket {
socket: RawSocket,
}
impl BorrowedSocket<'_> {
/// Return a `BorrowedSocket` holding the given raw socket.
///
/// # Safety
///
/// The resource pointed to by `raw` must remain open for the duration of
/// the returned `BorrowedSocket`, and it must not have the value
/// `INVALID_SOCKET`.
#[inline]
#[cfg_attr(
staged_api,
rustc_const_stable(feature = "io_safety", since = "1.63.0")
)]
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
pub const unsafe fn borrow_raw(socket: RawSocket) -> Self {
assert!(socket != c::INVALID_SOCKET as RawSocket);
Self {
socket,
_phantom: PhantomData,
}
}
}
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
impl AsRawSocket for BorrowedSocket<'_> {
#[inline]
fn as_raw_socket(&self) -> RawSocket {
self.socket
}
}
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
impl AsRawSocket for OwnedSocket {
#[inline]
fn as_raw_socket(&self) -> RawSocket {
self.socket
}
}
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
impl IntoRawSocket for OwnedSocket {
#[inline]
fn into_raw_socket(self) -> RawSocket {
let socket = self.socket;
forget(self);
socket
}
}
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
impl FromRawSocket for OwnedSocket {
#[inline]
unsafe fn from_raw_socket(socket: RawSocket) -> Self {
debug_assert_ne!(socket, c::INVALID_SOCKET as RawSocket);
Self { socket }
}
}
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
impl Drop for OwnedSocket {
#[inline]
fn drop(&mut self) {
unsafe {
let _ = c::closesocket(self.socket as LibcSocket);
}
}
}
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
impl fmt::Debug for BorrowedSocket<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("BorrowedSocket")
.field("socket", &self.socket)
.finish()
}
}
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
impl fmt::Debug for OwnedSocket {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("OwnedSocket")
.field("socket", &self.socket)
.finish()
}
}
/// A trait to borrow the socket from an underlying object.
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
pub trait AsSocket {
/// Borrows the socket.
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
fn as_socket(&self) -> BorrowedSocket<'_>;
}
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
impl<T: AsSocket> AsSocket for &T {
#[inline]
fn as_socket(&self) -> BorrowedSocket<'_> {
T::as_socket(self)
}
}
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
impl<T: AsSocket> AsSocket for &mut T {
#[inline]
fn as_socket(&self) -> BorrowedSocket<'_> {
T::as_socket(self)
}
}
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
impl AsSocket for BorrowedSocket<'_> {
#[inline]
fn as_socket(&self) -> BorrowedSocket<'_> {
*self
}
}
#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
impl AsSocket for OwnedSocket {
#[inline]
fn as_socket(&self) -> BorrowedSocket<'_> {
// Safety: `OwnedSocket` and `BorrowedSocket` have the same validity
// invariants, and the `BorrowdSocket` is bounded by the lifetime
// of `&self`.
unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) }
}
}
|
mod adventofcode;
use adventofcode::load_file;
use std::collections::HashSet;
#[cfg(test)]
mod tests {
use validate_passphrase;
#[test]
fn test1() {
let input = "abcde fghij";
assert_eq!(validate_passphrase(&input), true);
}
#[test]
fn test2() {
let input = "abcde xyz ecdab";
assert_eq!(validate_passphrase(&input), false);
}
#[test]
fn test3() {
let input = "a ab abc abd abf abj";
assert_eq!(validate_passphrase(&input), true);
}
#[test]
fn test4() {
let input = "iiii oiii ooii oooi oooo";
assert_eq!(validate_passphrase(&input), true);
}
#[test]
fn test5() {
let input = "oiii ioii iioi iiio";
assert_eq!(validate_passphrase(&input), false);
}
}
fn validate_passphrase(input: &str) -> bool {
let mut reduced_words = HashSet::new();
for w in input.trim().split_whitespace() {
let mut reduced_word: Vec<_> = w.chars().collect();
reduced_word.sort();
if reduced_words.contains(&reduced_word) {
return false;
}
else {
reduced_words.insert(reduced_word);
}
}
true
}
fn main() {
let input = load_file("inputs/04-2.txt").unwrap();
let count = input
.lines()
.map(|line| validate_passphrase(line))
.filter(|x| *x)
.count();
println!("{:?}", count);
}
|
#[macro_use]
extern crate lazy_static;
use regex::Regex;
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::path::Path;
struct Entry {
pw: String,
c: char,
min: usize,
max: usize,
}
fn check1(e: &Entry) -> bool {
let mut count: usize = 0;
for pc in e.pw.chars() {
if pc == e.c {
count += 1;
}
}
count >= e.min && count <= e.max
}
fn check2(e: &Entry) -> bool {
(e.pw.chars().nth(e.min-1).unwrap() == e.c) ^ (e.pw.chars().nth(e.max-1).unwrap() == e.c)
}
fn parse(s: String) -> Entry {
lazy_static! {
static ref RE: Regex = Regex::new(r"(\d+)-(\d+) (\w): (\w+)").unwrap();
}
let caps = RE.captures(&s).unwrap();
let min = caps.get(1).unwrap().as_str().parse::<usize>().unwrap();
let max = caps.get(2).unwrap().as_str().parse::<usize>().unwrap();
let c = caps.get(3).unwrap().as_str().chars().next().unwrap();
let pw = caps.get(4).unwrap().as_str();
Entry { pw: pw.to_string(), c , min, max}
}
fn lines_from_file(filename: impl AsRef<Path>) -> Vec<String> {
let file = File::open(filename).expect("no such file");
let buf = BufReader::new(file);
buf.lines()
.map(|l| l.expect("Could not parse line"))
.collect()
}
fn main() {
let lines = lines_from_file("input.txt");
let entries: Vec<Entry> = lines.into_iter().map(parse).collect();
let part1 = entries.iter().map(check1).filter(|b| *b).count();
let part2 = entries.iter().map(check2).filter(|b| *b).count();
println!("{} {}", part1, part2);
}
|
use std::{io, result, str};
use std::io::Read;
extern crate serde_json;
#[macro_use]
extern crate serde_derive;
mod simple;
pub use simple::open_simple;
mod memory;
pub use memory::open_memory;
mod wal;
pub use wal::open_wal;
#[derive(Debug)]
pub enum Error {
Io(io::Error),
Utf8Error(str::Utf8Error),
String(String),
JsonError(serde_json::Error),
}
impl From<io::Error> for Error {
fn from(err: io::Error) -> Error {
Error::Io(err)
}
}
impl From<str::Utf8Error> for Error {
fn from(err: str::Utf8Error) -> Error {
Error::Utf8Error(err)
}
}
impl From<String> for Error {
fn from(err: String) -> Error {
Error::String(err)
}
}
impl From<serde_json::Error> for Error {
fn from(err: serde_json::Error) -> Error {
Error::JsonError(err)
}
}
pub type Result<T> = result::Result<T, Error>;
pub trait Luxo {
fn read(&self, key: &[u8], read_value: &mut FnMut(&mut Read) -> usize)
-> Result<Option<usize>>;
fn write(&mut self, key: &[u8], size: usize, value: &mut Read) -> Result<u64>;
}
pub fn stats(folder: &String) {
println!("stats {}", folder)
}
|
use prob1::solver::Solver;
pub struct BruteForceSolver {
upper: u32,
}
impl BruteForceSolver {
pub fn new(upper_limit: u32) -> BruteForceSolver {
BruteForceSolver { upper: upper_limit }
}
}
impl Solver for BruteForceSolver {
fn sequence(&self) -> Box<Iterator<Item=u32>> {
Box::new((1..self.upper).filter(|n: &u32| n % 3 == 0 || n % 5 == 0))
}
}
|
// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use {
crate::error::Error,
wlan_common::{
appendable::Appendable,
big_endian::BigEndianU16,
mac::{self, MacAddr},
},
};
pub fn write_eth_frame<B: Appendable>(
buf: &mut B,
dst_addr: MacAddr,
src_addr: MacAddr,
protocol_id: u16,
body: &[u8],
) -> Result<(), Error> {
buf.append_value(&mac::EthernetIIHdr {
da: dst_addr,
sa: src_addr,
ether_type: BigEndianU16::from_native(protocol_id),
})?;
buf.append_bytes(body)?;
Ok(())
}
#[cfg(test)]
mod tests {
use {
super::*,
wlan_common::{assert_variant, buffer_writer::BufferWriter},
};
#[test]
fn eth_frame_ok() {
let mut buf = vec![];
write_eth_frame(&mut buf, [1; 6], [2; 6], 3333, &[4; 9])
.expect("failed writing ethernet frame");
assert_eq!(
&[
1, 1, 1, 1, 1, 1, // dst_addr
2, 2, 2, 2, 2, 2, // src_addr
0x0d, 0x05, // ether_type
4, 4, 4, 4, 4, 4, 4, 4, // payload
4, // more payload
],
&buf[..]
);
}
#[test]
fn eth_frame_buffer_too_small() {
let mut buf = [7u8; 22];
let write_result =
write_eth_frame(&mut BufferWriter::new(&mut buf[..]), [1; 6], [2; 6], 3333, &[4; 9]);
assert_variant!(write_result, Err(Error::BufferTooSmall));
}
#[test]
fn eth_frame_empty_payload() {
let mut buf = vec![];
write_eth_frame(&mut buf, [1; 6], [2; 6], 3333, &[])
.expect("failed writing ethernet frame");
assert_eq!(
&[
1, 1, 1, 1, 1, 1, // dst_addr
2, 2, 2, 2, 2, 2, // src_addrfx
0x0d, 0x05, // ether_type
],
&buf[..]
);
}
}
|
extern "C" {
fn malloc(x: usize) -> *mut u8;
fn free(x: *mut u8);
pub fn memset(ptr: *mut u8, val: i32, size: usize);
}
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
pub struct Page {
pub(super) data: *mut u8,
pub(super) top: *mut u8,
pub(super) limit: *mut u8,
pub(super) size: usize,
}
impl Page {
#[inline]
pub fn new(x: usize) -> Page {
let data = mmap(x, ProtType::Writable) as *mut u8;
//println!("Page ptr {:p}", data);
Page {
size: x,
data,
top: unsafe { data.offset(1) },
limit: unsafe { data.offset(x as isize) },
}
}
}
use std::collections::HashMap;
pub type HValueRefMap = HashMap<usize, HValueRef>;
pub type HValueRefList = Vec<HValueRef>;
pub type HValueWeakRefMap = HashMap<usize, HValueWeakRef>;
pub struct Heap {
pub new_space: *mut Space,
pub old_space: *mut Space,
pub last_stack: *mut u8,
pub last_frame: *mut u8,
pub pending_exception: *mut u8,
pub needs_gc: GCType,
pub factory: *mut HValue,
pub references: HValueRefMap,
pub weak_references: HValueWeakRefMap,
}
use std::alloc::Layout;
/*
impl Drop for Heap {
fn drop(&mut self) {
unsafe {
std::ptr::drop_in_place(self.new_space);
std::ptr::drop_in_place(self.old_space);
std::alloc::dealloc(self.new_space as _, Layout::new::<Space>());
std::alloc::dealloc(self.old_space as _, Layout::new::<Space>());
}
}
}*/
pub struct Ptr<T: ?Sized> {
pub val: *mut T,
}
impl<T> Ptr<T> {
pub fn from_raw(p: *mut T) -> Self {
Self { val: p }
}
}
impl<T: Drop> Ptr<T> {
pub fn drop(&self) {
unsafe { std::ptr::drop_in_place(self.val) };
}
}
impl<T: ?Sized> std::ops::Deref for Ptr<T> {
type Target = T;
fn deref(&self) -> &T {
unsafe { &*self.val }
}
}
impl<T: ?Sized> std::ops::DerefMut for Ptr<T> {
fn deref_mut(&mut self) -> &mut T {
unsafe { &mut *self.val }
}
}
impl Heap {
pub fn new(page_size: usize) -> Ptr<Heap> {
unsafe {
let h = Heap {
needs_gc: GCType::None,
old_space: std::ptr::null_mut(),
new_space: std::ptr::null_mut(),
last_stack: std::ptr::null_mut(),
last_frame: std::ptr::null_mut(),
pending_exception: std::ptr::null_mut(),
references: HashMap::new(),
weak_references: HashMap::new(),
factory: std::ptr::null_mut(),
};
let heap_ptr = Box::into_raw(Box::new(h));
let heap: &mut Heap = &mut *heap_ptr;
heap.old_space = Box::into_raw(Box::new(Space::new(page_size, heap_ptr)));
heap.new_space = Box::into_raw(Box::new(Space::new(page_size, heap_ptr)));
heap.factory = HValue::cast(HObject::new_empty(heap, 128));
let mut f = heap.factory;
heap.reference(RefType::Persistent, &mut f, f);
Ptr::from_raw(heap_ptr)
}
}
pub fn reference(&mut self, ty: RefType, reference: *mut *mut HValue, value: *mut HValue) {
let ref_ = HValueRef {
ty,
reference,
value,
};
self.references.insert(reference as _, ref_);
}
#[inline(never)]
pub fn allocate_tagged(&mut self, tag: HeapTag, tenure: Tenure, bytes: usize) -> *mut u8 {
let result = unsafe { self.space(tenure).allocate(bytes + 8) };
let mut qtag = tag as u8 as isize;
if tenure == Tenure::Old {
let bit_offset = (HValue::GENERATION_OFF - interior_offset(0)) << 3;
qtag = qtag | (5isize.wrapping_shl(bit_offset as _));
}
unsafe {
*(result.offset(HValue::TAG_OFFSET) as *mut isize) = qtag;
}
result
}
}
pub static mut HEAP: *mut Heap = std::ptr::null_mut();
pub fn get_heap() -> &'static mut Heap {
unsafe {
assert!(!HEAP.is_null());
&mut *HEAP
}
}
impl Heap {
pub unsafe fn space(&mut self, t: Tenure) -> &mut Space {
if t == Tenure::Old {
return &mut *self.old_space;
} else {
return &mut *self.new_space;
}
}
}
#[derive(Clone, PartialEq, Debug)]
pub struct Space {
pub top: *mut *mut u8,
pub limit: *mut *mut u8,
pub pages: Vec<Page>,
pub page_size: usize,
pub size: usize,
pub size_limit: usize,
pub heap: *mut Heap,
}
impl Drop for Space {
fn drop(&mut self) {
self.pages.clear();
}
}
impl Space {
pub fn new(page_size: usize, heap: *mut Heap) -> Space {
let mut space = Space {
page_size,
size: 0,
pages: vec![],
top: std::ptr::null_mut(),
limit: std::ptr::null_mut(),
size_limit: 0,
heap,
};
let page = Page::new(page_size);
space.select(&page);
space.pages.push(page);
space
}
pub fn compute_size_limit(&mut self) {
self.size_limit = self.size << 1;
}
pub fn select(&mut self, page: &Page) {
self.top = (&page.top) as *const *mut u8 as *mut *mut _;
self.limit = (&page.limit) as *const *mut u8 as *mut *mut _;
}
pub fn contains_pointer(&self, ptr: *mut u8) -> bool {
unsafe {
for page in self.pages.iter() {
if page.data.offset(1) as usize <= ptr as usize
&& page.data.offset(page_size() as _) as usize > ptr as usize
{
return true;
}
}
false
}
}
pub fn allocate(&mut self, bytes: usize) -> *mut u8 {
assert!(bytes != 0);
let even_bytes = bytes + (bytes & 0x01);
unsafe {
let place_in_current = (*self.top).offset(even_bytes as _) <= *self.limit;
if !place_in_current {
let mut i = 0;
let mut gap_found = false;
for item in self.pages.clone().iter() {
if (*self.top).offset(even_bytes as _) > *self.limit {
if i < self.pages.len() {
gap_found = true;
} else {
gap_found = false;
}
i = i + 1;
self.select(&item);
} else {
break;
}
}
if !gap_found {
if self.size > self.size_limit {
let heap: &mut Heap = &mut *self.heap;
if self as *const Space as *const u8 == heap.new_space as *const u8 {
heap.needs_gc = GCType::NewSpace;
} else {
heap.needs_gc = GCType::OldSpace;
}
}
self.add_page(even_bytes + 1);
}
}
let result = *self.top;
(*self.top) = (*self.top).offset(even_bytes as _);
return result;
}
}
pub fn clear(&mut self) {
self.size = 0;
for page in self.pages.iter() {
munmap(page.data, page_size() as usize);
}
self.pages.clear();
}
pub fn swap(&mut self, space: &mut Space) {
self.clear();
while space.pages.len() != 0 {
self.pages.push(space.pages.pop().unwrap());
self.size += self.pages.last().unwrap().size;
}
self.select(&self.pages.first().unwrap().clone());
self.compute_size_limit();
}
pub fn add_page(&mut self, size: usize) {
#[inline(always)]
fn roundup(value: u32, to: u32) -> u32 {
if value % to == 0 {
return value;
}
return value + to;
}
let real_size = roundup(size as _, self.page_size as _) as usize;
let page = Page::new(real_size);
self.size += real_size;
self.select(&page);
self.pages.push(page);
}
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
#[repr(u8)]
pub enum HeapTag {
Nil = 0x01,
Context,
Boolean,
Number,
String,
Object,
Array,
Function,
ExternData,
Map,
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
#[repr(u8)]
pub enum Tenure {
New = 0,
Old = 1,
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
#[repr(u8)]
pub enum GCType {
None = 0,
NewSpace = 1,
OldSpace = 2,
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
#[repr(u8)]
pub enum RefType {
Weak,
Persistent,
}
pub const MIN_OLD_SPACE_GEN: u8 = 5;
pub const MIN_FACTORY_SIZE: u8 = 128;
pub const ENTER_FRAME_TAG: usize = 0xFEEDBEEE;
pub const BINDING_CONTEXT_TAG: usize = 0x0DEC0DEC;
pub const IC_DISABLED_VALUE: usize = 0xABBAABBA;
pub const IC_ZAP_VALUE: usize = 0xABBADEEC;
pub trait HValTrait: Sized + Copy {
fn addr(&self) -> *mut u8 {
unsafe { std::mem::transmute(self) }
}
const TAG: HeapTag;
}
const fn interior_offset(x: isize) -> isize {
return x * std::mem::size_of::<isize>() as isize - 1;
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
pub struct HValue;
impl HValTrait for HValue {
const TAG: HeapTag = HeapTag::Nil;
}
impl HValue {
pub const TAG_OFFSET: isize = interior_offset(0);
pub const GC_MARK_OFF: isize = interior_offset(1) - 1;
pub const GC_FORWARD_OFF: isize = interior_offset(1);
pub const REPR_OFF: isize = interior_offset(0) + 1;
pub const GENERATION_OFF: isize = interior_offset(0) + 2;
pub fn is_soft_gc_marked(&self) -> bool {
if Self::is_unboxed(self.addr()) {
return false;
}
unsafe {
return (*self.addr().offset(HValue::GC_MARK_OFF)) & 0x40 != 0;
}
}
pub fn set_soft_gc_mark(&self) {
unsafe {
*(self.addr().offset(Self::GC_MARK_OFF)) |= 0x40;
//*(self.addr().offset(Self::GC_FORWARD_OFF) as *mut *mut u8) = new_addr;
}
}
pub fn reset_soft_gc_mark(&self) {
unsafe {
if self.is_soft_gc_marked() {
*(self.addr().offset(Self::GC_MARK_OFF)) ^= 0x40;
}
}
}
pub fn generation(&self) -> u8 {
return unsafe { *self.addr().offset(Self::GENERATION_OFF) };
}
pub fn increment_generation(&self) {
if self.generation() < 5 {
unsafe {
let slot = self.addr().offset(Self::GENERATION_OFF);
*slot = *slot + 1;
}
}
}
#[inline]
pub fn is_gc_marked(&self) -> bool {
if Self::is_unboxed(self.addr()) {
return false;
}
unsafe {
return (*self.addr().offset(HValue::GC_MARK_OFF)) & 0x80 != 0;
}
}
#[inline]
pub fn is_unboxed(addr: *mut u8) -> bool {
return (addr as usize & 0x01) == 0;
}
#[inline]
pub const fn cast(addr: *mut u8) -> *mut HValue {
return addr as *mut HValue;
}
pub fn tag(&self) -> HeapTag {
Self::get_tag(self.addr())
}
pub fn as_<T: HValTrait>(&self) -> *mut T {
assert!(self.tag() == T::TAG);
return unsafe { std::mem::transmute(self) };
}
pub fn get_tag(addr: *mut u8) -> HeapTag {
if addr == (HeapTag::Nil as u8 as *mut u8) {
return HeapTag::Nil;
}
if Self::is_unboxed(addr) {
return HeapTag::Number;
}
return unsafe { std::mem::transmute(*addr.offset(Self::TAG_OFFSET)) };
}
pub fn get_repr(addr: *mut u8) -> u8 {
return unsafe { std::mem::transmute(*(addr.offset(Self::REPR_OFF))) };
}
pub fn get_gc_mark(&self) -> *mut u8 {
return unsafe { *(self.addr().offset(Self::GC_FORWARD_OFF) as *mut *mut u8) };
}
pub fn is_marked(&self) -> bool {
if HValue::is_unboxed(self.addr()) {
return false;
}
return unsafe { (*self.addr().offset(Self::GC_MARK_OFF) & 0x80) != 0 };
}
pub fn set_gc_mark(&self, new_addr: *mut u8) {
unsafe {
*(self.addr().offset(Self::GC_MARK_OFF)) |= 0x80;
*(self.addr().offset(Self::GC_FORWARD_OFF) as *mut *mut u8) = new_addr;
}
}
pub fn size(&self) -> usize {
const PTR_SIZE: usize = 8;
unsafe {
let mut size = PTR_SIZE;
match self.tag() {
HeapTag::Context => {
size += (2 * (*self.as_::<HContext>()).slots() as usize) * PTR_SIZE;
}
HeapTag::Function => {
size += 4 * PTR_SIZE;
}
HeapTag::Number => {
size += 8;
}
HeapTag::Boolean => {
size += 8;
}
HeapTag::String => {
size += 2 * PTR_SIZE;
match Self::get_repr(self.addr()) {
0 => {
size += (*self.as_::<HString>()).length() as usize;
}
_ => {
size += 2 * PTR_SIZE;
}
}
}
HeapTag::Object => {
size += 3 * PTR_SIZE;
}
HeapTag::Array => {
size += 4 * PTR_SIZE;
}
HeapTag::Map => {
size += (1 + ((*self.as_::<HMap>()).size() as usize) << 1) * PTR_SIZE;
}
HeapTag::ExternData => {
size += std::mem::size_of::<usize>() + HCData::size(self.addr()) as usize;
}
_ => (),
}
size
}
}
pub fn copy_to(&self, old_space: &mut Space, new_space: &mut Space) -> *mut HValue {
assert!(!Self::is_unboxed(self.addr()));
const PTR_SIZE: usize = std::mem::size_of::<usize>();
unsafe {
let mut size = PTR_SIZE;
match self.tag() {
HeapTag::Context => {
size += (2 * (*self.as_::<HContext>()).slots() as usize) * PTR_SIZE;
}
HeapTag::Function => {
size += 4 * PTR_SIZE;
}
HeapTag::Number => {
size += 8;
}
HeapTag::Boolean => {
size += 8;
}
HeapTag::String => {
size += 2 * PTR_SIZE;
match Self::get_repr(self.addr()) {
0 => {
size += (*self.as_::<HString>()).length() as usize;
}
_ => {
size += 2 * PTR_SIZE;
}
}
}
HeapTag::Object => {
size += 3 * PTR_SIZE;
}
HeapTag::Array => {
size += 4 * PTR_SIZE;
}
HeapTag::Map => {
size += (1 + ((*self.as_::<HMap>()).size() as usize) << 1) * PTR_SIZE;
}
HeapTag::ExternData => {
size += std::mem::size_of::<usize>() + HCData::size(self.addr()) as usize;
}
_ => unreachable!(),
}
self.increment_generation();
let result;
if self.generation() >= 5 {
result = old_space.allocate(size);
} else {
result = new_space.allocate(size);
}
std::ptr::copy_nonoverlapping(
self.addr().offset(interior_offset(0)),
result.offset(interior_offset(0)),
size,
);
return HValue::cast(result);
}
}
/*pub fn copy_to(&self, addr: &mut crate::gc::Address) -> (*mut u8, usize) {
const PTR_SIZE: usize = 8;
unsafe {
let mut size = PTR_SIZE;
match self.tag() {
HeapTag::Context => {
size += (2 * (*self.as_::<HContext>()).slots() as usize) * PTR_SIZE;
}
HeapTag::Function => {
size += 4 * PTR_SIZE;
}
HeapTag::Number => {
size += 8;
}
HeapTag::Boolean => {
size += 8;
}
HeapTag::String => {
size += 2 * PTR_SIZE;
match Self::get_repr(self.addr()) {
0 => {
size += (*self.as_::<HString>()).length() as usize;
}
_ => {
size += 2 * PTR_SIZE;
}
}
}
HeapTag::Object => {
size += 3 * PTR_SIZE;
}
HeapTag::Array => {
size += 4 * PTR_SIZE;
}
HeapTag::Map => {
size += (1 + ((*self.as_::<HMap>()).size() as usize) << 1) * PTR_SIZE;
}
_ => unimplemented!(),
}
let result = self.addr().offset(interior_offset(0));
std::ptr::copy_nonoverlapping(
result,
addr.to_mut_ptr::<u8>().offset(interior_offset(0)),
size,
);
return (result, size);
}
}*/
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
pub struct HBoolean;
impl HValTrait for HBoolean {
const TAG: HeapTag = HeapTag::Boolean;
}
impl HBoolean {
pub fn new(heap: &mut Heap, tenure: Tenure, value: bool) -> *mut u8 {
unsafe {
let result = heap.allocate_tagged(HeapTag::Boolean, tenure, 8);
*(result.offset(Self::VALUE_OFFSET)) = if value { 1 } else { 0 };
result
}
}
pub fn value(addr: *mut u8) -> bool {
return unsafe { *(addr.offset(Self::VALUE_OFFSET)) != 0 };
}
pub fn is_true(&self) -> bool {
HBoolean::value(self.addr())
}
pub fn is_false(&self) -> bool {
HBoolean::value(self.addr())
}
pub const VALUE_OFFSET: isize = interior_offset(1);
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
pub struct HContext;
impl HValTrait for HContext {
const TAG: HeapTag = HeapTag::Context;
}
impl HContext {
pub fn parent_slot(&self) -> *mut *mut u8 {
return unsafe { (self.addr().offset(Self::PARENT_OFFSET)) as *mut *mut _ };
}
pub fn parent(&self) -> *mut u8 {
unsafe { *self.parent_slot() }
}
pub fn has_parent(&self) -> bool {
!self.parent().is_null()
}
pub fn get_slot(&self, idx: u32) -> *mut HValue {
unsafe { HValue::cast(*self.get_slot_address(idx)) }
}
pub fn has_slot(&self, idx: u32) -> bool {
return unsafe { *self.get_slot_address(idx) != HeapTag::Nil as u8 as *mut u8 };
}
pub fn get_slot_address(&self, idx: u32) -> *mut *mut u8 {
return unsafe { (self.addr().offset(Self::get_index_disp(idx))) as *mut *mut u8 };
}
pub fn get_index_disp(index: u32) -> isize {
return interior_offset(3 + index as isize);
}
pub fn slots(&self) -> usize {
return unsafe { *(self.addr().offset(Self::SLOTS_OFFSET) as *mut usize) };
}
pub const PARENT_OFFSET: isize = interior_offset(1);
pub const SLOTS_OFFSET: isize = interior_offset(2);
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
#[repr(u8)]
pub enum StrRepr {
Normal = 0x00,
Cons = 0x01,
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
pub struct HString;
impl HValTrait for HString {
const TAG: HeapTag = HeapTag::String;
}
impl HString {
pub const HASH_OFFSET: isize = interior_offset(1);
pub const LENGTH_OFFSET: isize = interior_offset(2);
pub const VALUE_OFFSET: isize = interior_offset(3);
pub const LEFT_CONS_OFFSET: isize = interior_offset(3);
pub const RIGHT_CONS_OFFSET: isize = interior_offset(4);
pub const MIN_CONS_LEN: usize = 24;
pub fn new(heap: &mut Heap, tenure: Tenure, length: usize, value: Option<&str>) -> *mut u8 {
unsafe {
let result = heap.allocate_tagged(
HeapTag::String,
tenure,
length + 3 * std::mem::size_of::<usize>(),
);
(result.offset(Self::HASH_OFFSET) as *mut isize).write(0);
(result.offset(Self::LENGTH_OFFSET) as *mut usize).write(length);
if let Some(value) = value {
std::ptr::copy_nonoverlapping(
value.as_bytes().as_ptr(),
result.offset(Self::VALUE_OFFSET),
length,
);
}
result
}
}
pub fn static_length(addr: *mut u8) -> u32 {
return unsafe { *(addr.offset(HString::LENGTH_OFFSET) as *mut u32) };
}
pub fn left_cons(addr: *mut u8) -> *mut u8 {
unsafe { *HString::left_cons_slot(addr) }
}
pub fn right_cons(addr: *mut u8) -> *mut u8 {
unsafe { *HString::right_cons_slot(addr) }
}
pub fn left_cons_slot(addr: *mut u8) -> *mut *mut u8 {
unsafe { addr.offset(Self::LEFT_CONS_OFFSET) as *mut *mut u8 }
}
pub fn right_cons_slot(addr: *mut u8) -> *mut *mut u8 {
unsafe { addr.offset(Self::RIGHT_CONS_OFFSET) as *mut *mut u8 }
}
pub fn flatten_cons(mut addr: *mut u8, mut buffer: *mut u8) -> *mut u8 {
unsafe {
while !addr.is_null() {
match HValue::get_repr(addr) {
0x00 => {
let len = HString::static_length(addr);
std::ptr::copy_nonoverlapping(
addr.offset(Self::VALUE_OFFSET),
buffer,
len as _,
);
return buffer.offset(len as _);
}
0x01 => {
let left = Self::left_cons(addr);
let right = Self::right_cons(addr);
if right == HNil::new() {
addr = left;
} else {
if HString::static_length(left) > HString::static_length(right) {
Self::flatten_cons(
right,
buffer.offset(HString::static_length(left) as _),
);
addr = left;
} else {
buffer = Self::flatten_cons(left, buffer);
addr = right;
}
}
}
_ => unreachable!(),
}
}
return buffer;
}
}
pub fn value_as_str(heap: *mut Heap, addr: *mut u8) -> String {
let val = Self::value(heap, addr);
let len = Self::static_length(addr);
let slice = unsafe { std::slice::from_raw_parts(val, len as _) };
return String::from_utf8(slice.to_vec()).unwrap();
}
pub fn value(heap: *mut Heap, addr: *mut u8) -> *mut u8 {
unsafe {
match HValue::get_repr(addr) {
0x00 => return addr.offset(Self::VALUE_OFFSET),
0x01 => {
if Self::right_cons(addr) == HNil::new() {
return HString::value(heap, Self::left_cons(addr));
} else {
let result = HString::new(
&mut *heap,
Tenure::New,
HString::static_length(addr) as _,
None,
);
let value = HString::value(heap, result);
HString::flatten_cons(addr, value);
*Self::right_cons_slot(addr) = HNil::new();
*Self::left_cons_slot(addr) = result;
return value;
}
}
_ => unreachable!(),
}
}
}
pub fn length(&self) -> u32 {
Self::static_length(self.addr())
}
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
pub struct HMap;
impl HValTrait for HMap {
const TAG: HeapTag = HeapTag::Map;
}
impl HMap {
pub fn new_empty(heap: &mut Heap, mut size: usize) -> *mut u8 {
unsafe {
let map = heap.allocate_tagged(
HeapTag::Map,
Tenure::New,
((size << 1) + 1) * std::mem::size_of::<usize>(),
);
*(map.offset(Self::SIZE_OFFSET) as *mut usize) = size as usize;
size = (size << 1) * std::mem::size_of::<usize>();
memset(map.offset(Self::SPACE_OFFSET), 0x00, size);
let mut i = 0;
while i < size {
*map.offset(i as isize + Self::SPACE_OFFSET as isize) = HeapTag::Nil as u8;
i += std::mem::size_of::<usize>();
}
map
}
}
pub fn size(&self) -> u32 {
let size = unsafe { *(self.addr().offset(Self::SIZE_OFFSET) as *mut usize) } as u32;
size
}
pub fn get_slot_address(&self, index: u32) -> *mut *mut u8 {
return unsafe {
self.space()
.offset(index as isize * std::mem::size_of::<usize>() as isize)
as *mut *mut _
};
}
pub fn is_empty_slot(&self, index: u32) -> bool {
unsafe { *self.get_slot_address(index) == HNil::new() }
}
pub fn get_slot(&self, index: u32) -> *mut HValue {
return unsafe { HValue::cast(*self.get_slot_address(index)) };
}
pub fn has_slot(&self, index: u32) -> bool {
unsafe { *self.get_slot_address(index) != HeapTag::Nil as u8 as *mut u8 }
}
pub fn space(&self) -> *mut u8 {
unsafe { self.addr().offset(Self::SPACE_OFFSET) }
}
pub const SPACE_OFFSET: isize = interior_offset(2);
pub const SIZE_OFFSET: isize = interior_offset(1);
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
#[repr(C)]
pub struct HArray;
impl HValTrait for HArray {
const TAG: HeapTag = HeapTag::Array;
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
#[repr(C)]
pub struct HNumber;
impl HNumber {
pub fn new(value: i64) -> *mut u8 {
return Self::tag(value) as *mut _;
}
pub fn newf(heap: &mut Heap, tenure: Tenure, value: f64) -> *mut u8 {
unsafe {
let result = heap.allocate_tagged(HeapTag::Number, tenure, 8);
*(result.offset(Self::VALUE_OFFSET) as *mut f64) = value;
return result;
}
}
pub const VALUE_OFFSET: isize = interior_offset(1);
pub const fn tag(value: i64) -> i64 {
return value << 1;
}
pub const fn untag(value: i64) -> i64 {
return value >> 1;
}
pub fn to_ptr(value: i64) -> *mut u8 {
let oval = Self::tag(value) as *mut u8;
oval
}
pub fn integral_value(addr: *mut u8) -> i64 {
if HValue::is_unboxed(addr) {
return Self::untag(addr as _);
} else {
return unsafe { *(addr.offset(Self::VALUE_OFFSET) as *const f64) as i64 };
}
}
pub fn double_value(addr: *mut u8) -> f64 {
if HValue::is_unboxed(addr) {
return f64::from_bits(Self::untag(addr as _) as _);
} else {
return unsafe { *(addr.offset(Self::VALUE_OFFSET) as *const f64) };
}
}
}
impl HArray {
pub fn length(obj: *mut u8, shrink: bool) -> isize {
unsafe {
let mut result = *(obj.offset(Self::LENGTH_OFFSET) as *mut isize);
if shrink {
let mut shrinked = result;
let mut shrinked_ptr: *mut u8;
let mut slot: *mut *mut u8;
loop {
if shrinked < 0 {
break;
} else {
shrinked -= 1;
shrinked_ptr = HNumber::tag(shrinked as i64) as *mut u8;
slot = std::ptr::null_mut();
}
if *slot != HNil::new() {
break;
}
}
if result != (shrinked + 1) {
result = shrinked + 1;
HArray::set_length(obj, result);
}
}
result
}
}
pub fn is_dense(addr: *mut u8) -> bool {
unsafe {
let size = (*(addr as *mut HObject)).map() as *mut HMap;
let size = (*size).size();
return size <= Self::DENSE_LENGTH_MAX as u32;
}
}
pub fn set_length(obj: *mut u8, len: isize) {
unsafe {
*(obj.offset(Self::LENGTH_OFFSET) as *mut isize) = len;
}
}
pub const VAR_ARG_LEN: usize = 16;
pub const DENSE_LENGTH_MAX: usize = 128;
pub const LENGTH_OFFSET: isize = interior_offset(4);
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
#[repr(C)]
pub struct HObject;
impl HValTrait for HObject {
const TAG: HeapTag = HeapTag::Object;
}
impl HObject {
pub fn new_empty(heap: &mut Heap, size: usize) -> *mut u8 {
let obj = heap.allocate_tagged(
HeapTag::Object,
Tenure::New,
3 * std::mem::size_of::<usize>(),
);
HObject::init(heap, obj, size);
obj
}
pub fn init(heap: &mut Heap, obj: *mut u8, size: usize) {
unsafe {
*(obj.offset(Self::MASK_OFFSET) as *mut isize) =
(size as isize - 1) * std::mem::size_of::<usize>() as isize;
let map = HMap::new_empty(heap, size);
*(obj.offset(Self::MAP_OFFSET) as *mut *mut u8) = map;
*(obj.offset(Self::PROTO_OFFSET) as *mut *mut u8) = map;
}
}
pub fn map_slot_s(addr: *mut u8) -> *mut *mut u8 {
return unsafe { addr.offset(Self::MAP_OFFSET) as *mut *mut _ };
}
pub fn map_s(addr: *mut u8) -> *mut u8 {
return unsafe { *Self::map_slot_s(addr) };
}
pub fn map(&self) -> *mut u8 {
Self::map_s(self.addr())
}
pub fn map_slot(&self) -> *mut *mut u8 {
Self::map_slot_s(self.addr())
}
pub fn proto_slot_s(addr: *mut u8) -> *mut *mut u8 {
return unsafe { addr.offset(Self::PROTO_OFFSET) as *mut *mut _ };
}
pub fn proto_s(addr: *mut u8) -> *mut u8 {
unsafe { *Self::proto_slot_s(addr) }
}
pub fn proto(&self) -> *mut u8 {
Self::proto_s(self.addr())
}
pub fn proto_slot(&self) -> *mut *mut u8 {
Self::proto_slot_s(self.addr())
}
pub fn mask_slot(addr: *mut u8) -> *mut u32 {
unsafe { return addr.offset(Self::MASK_OFFSET) as *mut _ }
}
pub fn mask(addr: *mut u8) -> u32 {
unsafe { *Self::mask_slot(addr) }
}
pub fn lookup_property(
heap: *mut Heap,
addr: *mut u8,
key: *mut u8,
insert: bool,
) -> *mut *mut u8 {
unsafe {
let offset = crate::runtime::rt_lookup_property(heap, addr, key, insert);
return HObject::map_s(addr).offset(offset as _) as *mut *mut u8;
}
}
pub const MASK_OFFSET: isize = interior_offset(1);
pub const MAP_OFFSET: isize = interior_offset(2);
pub const PROTO_OFFSET: isize = interior_offset(3);
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
#[repr(C)]
pub struct HFunction;
impl HValTrait for HFunction {
const TAG: HeapTag = HeapTag::Function;
}
impl HFunction {
pub const PARENT_OFFSET: isize = interior_offset(1);
pub const CODE_OFFSET: isize = interior_offset(2);
pub const ROOT_OFFSET: isize = interior_offset(3);
pub const ARGC_OFFSET: isize = interior_offset(4);
pub fn root_s(addr: *mut u8) -> *mut u8 {
unsafe { *(addr.offset(Self::ROOT_OFFSET) as *mut *mut u8) }
}
pub fn root_slot(&self) -> *mut *mut u8 {
unsafe { self.addr().offset(Self::ROOT_OFFSET) as *mut *mut u8 }
}
pub fn root(&self) -> *mut u8 {
unsafe { *(self.root_slot()) }
}
pub fn argc(&self) -> u32 {
unsafe { *self.argc_off() }
}
pub fn parent(&self) -> *mut u8 {
unsafe { *self.parent_slot() }
}
pub fn parent_slot(&self) -> *mut *mut u8 {
unsafe { self.addr().offset(Self::PARENT_OFFSET) as *mut *mut _ }
}
pub fn argc_off(&self) -> *mut u32 {
unsafe { self.addr().offset(Self::ARGC_OFFSET) as *mut u32 }
}
}
#[derive(Clone, PartialEq, PartialOrd, Copy, Debug, Hash)]
pub struct HValueRef {
pub ty: RefType,
pub reference: *mut *mut HValue,
pub value: *mut HValue,
}
impl HValueRef {
pub fn value_ptr(&self) -> *const *mut HValue {
return &self.value as *const _;
}
pub fn is_weak(&self) -> bool {
self.ty == RefType::Weak
}
pub fn is_persistent(&self) -> bool {
self.ty == RefType::Persistent
}
pub fn make_weak(&mut self) {
self.ty = RefType::Weak;
}
pub fn make_persistent(&mut self) {
self.ty = RefType::Persistent;
}
}
#[derive(Clone, PartialEq, PartialOrd, Copy, Debug, Hash)]
pub struct HValueWeakRef {
pub value: *mut HValue,
pub callback: *const u8,
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
#[repr(C)]
pub struct HNil;
impl HValTrait for HNil {
const TAG: HeapTag = HeapTag::Nil;
}
impl HNil {
pub fn new() -> *mut u8 {
return Self::TAG as u8 as *mut u8;
}
}
#[derive(Copy, Clone, Debug, Hash, PartialEq, PartialOrd, Ord, Eq)]
#[repr(C)]
pub struct HCData;
impl HValTrait for HCData {
const TAG: HeapTag = HeapTag::ExternData;
}
impl HCData {
pub fn new(heap: &mut Heap, size: usize) -> *mut u8 {
unsafe {
let d = heap.allocate_tagged(
HeapTag::ExternData,
Tenure::New,
std::mem::size_of::<usize>() + size,
);
*(d.offset(Self::SIZE_OFFSET) as *mut u32) = size as u32;
return d;
}
}
pub fn size(addr: *mut u8) -> u32 {
return unsafe { *(addr.offset(Self::SIZE_OFFSET) as *mut u32) };
}
pub fn data(addr: *mut u8) -> *mut u8 {
return unsafe { addr.offset(Self::DATA_OFFSET) };
}
pub const SIZE_OFFSET: isize = interior_offset(1);
pub const DATA_OFFSET: isize = interior_offset(2);
}
#[cfg(not(target_family = "windows"))]
use libc;
use std::ptr;
static mut PAGE_SIZE: u32 = 0;
static mut PAGE_SIZE_BITS: u32 = 0;
pub fn init_page_size() {
unsafe {
PAGE_SIZE = determine_page_size();
assert!((PAGE_SIZE & (PAGE_SIZE - 1)) == 0);
}
}
#[cfg(target_family = "unix")]
pub(crate) fn determine_page_size() -> u32 {
let val = unsafe { libc::sysconf(libc::_SC_PAGESIZE) };
if val <= 0 {
panic!("could not determine page size.");
}
val as u32
}
#[cfg(target_family = "windows")]
#[allow(deprecated)]
pub(crate) fn determine_page_size() -> u32 {
use std::mem;
use winapi::um::sysinfoapi::{GetSystemInfo, SYSTEM_INFO};
unsafe {
let mut system_info: SYSTEM_INFO = mem::uninitialized();
GetSystemInfo(&mut system_info);
system_info.dwPageSize
}
}
pub fn page_size() -> u32 {
unsafe { PAGE_SIZE }
}
#[derive(Copy, Clone, PartialEq, Eq)]
pub(crate) enum ProtType {
Executable,
Writable,
None,
}
impl ProtType {
#[cfg(target_family = "unix")]
fn to_libc(self) -> libc::c_int {
match self {
ProtType::None => 0,
ProtType::Writable => libc::PROT_READ | libc::PROT_WRITE,
ProtType::Executable => libc::PROT_READ | libc::PROT_EXEC,
}
}
}
#[cfg(target_family = "unix")]
pub(crate) fn mmap(size: usize, prot: ProtType) -> *const u8 {
let ptr = unsafe {
libc::mmap(
ptr::null_mut(),
size,
prot.to_libc(),
libc::MAP_PRIVATE | libc::MAP_ANON,
-1,
0,
) as *mut libc::c_void
};
if ptr == libc::MAP_FAILED {
panic!("mmap failed");
}
ptr as *const u8
}
#[cfg(target_family = "windows")]
pub(crate) fn mmap(size: usize, exec: ProtType) -> *const u8 {
use winapi::um::memoryapi::VirtualAlloc;
use winapi::um::winnt::{MEM_COMMIT, MEM_RESERVE, PAGE_EXECUTE_READWRITE, PAGE_READWRITE};
let prot = if exec == ProtType::Executable {
PAGE_EXECUTE_READWRITE
} else {
PAGE_READWRITE
};
let ptr = unsafe { VirtualAlloc(ptr::null_mut(), size, MEM_COMMIT | MEM_RESERVE, prot) };
if ptr.is_null() {
use winapi::um::errhandlingapi::GetLastError;
panic!(
"VirtualAlloc failed with error code '{:x}',size '{}'",
unsafe { GetLastError() },
size
);
}
ptr as *const u8
}
#[cfg(target_family = "unix")]
pub(crate) fn munmap(ptr: *const u8, size: usize) {
let res = unsafe { libc::munmap(ptr as *mut libc::c_void, size) };
if res != 0 {
panic!("munmap failed");
}
}
#[cfg(target_family = "windows")]
pub(crate) fn munmap(ptr: *const u8, _size: usize) {
use winapi::um::memoryapi::VirtualFree;
use winapi::um::winnt::MEM_RELEASE;
let res = unsafe { VirtualFree(ptr as *mut _, 0, MEM_RELEASE) };
if res == 0 {
panic!("VirtualFree failed");
}
}
|
extern crate oxygen;
use oxygen::lexer::Lexer;
use oxygen::reader::Reader;
use oxygen::syntax::token::{TokenType};
const SRC: &'static str = "\
let int = 1\n\
let dbl = 1.1\n\
let str = \"hello\"\n\
\n\
fn hello(a, b, c) {\n\
return a + b + c\n\
}\n\
\n\
listen some.evnt {\n\
hello(1, 2, 3)\n\
emit my.event \"no\"\n\
}";
fn main() {
let reader = Reader::new(SRC.to_string());
let mut lexer = Lexer::new(reader);
loop {
// TIP: Use next_trimmed to remove
// spaces and duplicate newlines
match lexer.next() {
Ok(token) => {
println!("{:?}", token);
if *token.get_type() == TokenType::Eof {
break;
}
},
Err(err) => {
println!("Error: {:?}", err);
break;
}
}
}
}
|
use crate::{instruction::Instruction, optimizer, parser};
use std::{collections::VecDeque, io, ops::Range};
const TAPE_SIZE: usize = 30_000;
pub type Result = std::result::Result<(), Error>;
pub struct Brainfuck {
instructions: VecDeque<Instruction>,
ip: usize,
tape: [u8; TAPE_SIZE],
dp: usize,
stack: Vec<usize>,
}
#[derive(Debug)]
pub enum Error {
ReadError(io::Error),
WriteError(io::Error),
UnbalancedParens,
}
impl Brainfuck {
pub fn new(program: &str) -> Brainfuck {
let instructions = parser::parse(program.as_bytes());
let optimized_instructions = optimizer::optimize(instructions);
Brainfuck {
instructions: optimized_instructions,
ip: 0,
tape: [0; TAPE_SIZE],
dp: 0,
stack: Vec::new(),
}
}
#[allow(dead_code)]
pub fn tape_pointer(&self) -> usize {
self.dp
}
#[allow(dead_code)]
pub fn tape(&self, range: Range<usize>) -> &[u8] {
&self.tape[range]
}
#[allow(dead_code)]
pub fn run_pure(&mut self) -> Result {
self.run(&mut io::empty(), &mut io::sink())
}
pub fn run<R, W>(&mut self, input: &mut R, output: &mut W) -> Result
where
R: io::Read,
W: io::Write,
{
loop {
match self.current() {
Some(&Instruction::Right(n)) => {
if self.dp + n < self.tape.len() - 1 {
self.dp += n;
} else {
self.dp = self.tape.len();
}
}
Some(&Instruction::Left(n)) => {
self.dp = self.dp.saturating_sub(n);
}
Some(&Instruction::Add(n)) => {
let byte = self.get_byte().wrapping_add(n);
self.set_byte(byte);
}
Some(&Instruction::Sub(n)) => {
let byte = self.get_byte().wrapping_sub(n);
self.set_byte(byte);
}
Some(&Instruction::Out) => {
let _ = output
.write(&[self.get_byte()])
.map_err(Error::WriteError)?;
}
Some(&Instruction::In) => {
let mut buffer = [0; 1];
let _ = input.read(&mut buffer).map_err(Error::ReadError)?;
self.set_byte(buffer[0]);
}
Some(&Instruction::Open) => {
if self.get_byte() == 0 {
self.advance_to_matching_paren();
} else {
self.push();
}
}
Some(&Instruction::Close) => {
if self.get_byte() != 0 {
self.return_to_matching_paren()?;
} else {
self.pop();
}
}
None => {
break;
}
};
self.advance();
}
Ok(())
}
#[inline(always)]
fn set_byte(&mut self, byte: u8) {
self.tape[self.dp] = byte;
}
#[inline(always)]
fn get_byte(&self) -> u8 {
self.tape[self.dp]
}
#[inline(always)]
fn advance(&mut self) {
self.ip += 1;
}
#[inline(always)]
fn current(&self) -> Option<&Instruction> {
self.instructions.get(self.ip)
}
#[inline(always)]
fn pop(&mut self) {
let _ = self.stack.pop();
}
#[inline(always)]
fn push(&mut self) {
self.stack.push(self.ip);
}
#[inline(always)]
fn advance_to_matching_paren(&mut self) {
let mut c = 0;
loop {
self.advance();
match self.current() {
None | Some(&Instruction::Close) if c == 0 => break,
Some(&Instruction::Close) => c -= 1,
Some(&Instruction::Open) => c += 1,
_ => {}
}
}
}
#[inline(always)]
fn return_to_matching_paren(&mut self) -> Result {
match self.stack.last() {
Some(ip) => {
self.ip = *ip;
}
None => return Err(Error::UnbalancedParens),
}
Ok(())
}
}
#[cfg(test)]
mod test {
use super::Brainfuck;
use std::io;
#[test]
fn initialized() {
let brainfuck = Brainfuck::new("");
assert_eq!(0, brainfuck.tape_pointer());
assert_eq!(&[0, 0, 0, 0], brainfuck.tape(0..4));
}
#[test]
fn instruction_greater_than() {
let mut brainfuck = Brainfuck::new(">");
brainfuck.run_pure().unwrap();
assert_eq!(1, brainfuck.tape_pointer());
}
#[test]
fn instruction_less_than() {
let mut brainfuck = Brainfuck::new("<");
brainfuck.run_pure().unwrap();
assert_eq!(0, brainfuck.tape_pointer());
}
#[test]
fn instruction_less_than_2() {
let mut brainfuck = Brainfuck::new(">><");
brainfuck.run_pure().unwrap();
assert_eq!(1, brainfuck.tape_pointer());
}
#[test]
fn instruction_plus() {
let mut brainfuck = Brainfuck::new("+");
brainfuck.run_pure().unwrap();
assert_eq!(&[1], brainfuck.tape(0..1));
}
#[test]
fn instruction_plus_2() {
let mut brainfuck = Brainfuck::new("++>++>++");
brainfuck.run_pure().unwrap();
assert_eq!(&[2, 2, 2], brainfuck.tape(0..3));
}
#[test]
fn instruction_minus() {
let mut brainfuck = Brainfuck::new("-");
brainfuck.run_pure().unwrap();
assert_eq!(&[255], brainfuck.tape(0..1));
}
#[test]
fn instruction_minus_2() {
let mut brainfuck = Brainfuck::new("-->-->--");
brainfuck.run_pure().unwrap();
assert_eq!(&[254, 254, 254], brainfuck.tape(0..3));
}
#[test]
fn instruction_dot() {
let mut output: Vec<u8> = Vec::new();
let mut brainfuck = Brainfuck::new(".");
brainfuck.run(&mut io::empty(), &mut output).unwrap();
assert_eq!(vec!(0), output);
}
#[test]
fn instruction_dot_2() {
let mut output = Vec::new();
let mut brainfuck = Brainfuck::new("+>++>+++.<.<.");
brainfuck.run(&mut io::empty(), &mut output).unwrap();
assert_eq!(vec!(3, 2, 1), output);
}
#[test]
fn instruction_comma() {
let input = [5, 4, 3];
let mut brainfuck = Brainfuck::new(",>,>,");
brainfuck.run(&mut input.as_ref(), &mut io::sink()).unwrap();
assert_eq!(&[5, 4, 3], brainfuck.tape(0..3));
}
#[test]
fn instruction_comma_2() {
let input = [5, 4, 3];
let mut output = Vec::new();
let mut brainfuck = Brainfuck::new(",.>,.>,.");
brainfuck.run(&mut input.as_ref(), &mut output).unwrap();
assert_eq!(vec!(5, 4, 3), output);
}
#[test]
fn hello_world() {
let mut brainfuck = Brainfuck::new(
"++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---\
.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.\n",
);
let mut output = Vec::new();
brainfuck.run(&mut io::empty(), &mut output).unwrap();
assert_eq!("Hello World!\n", String::from_utf8(output).unwrap());
}
#[test]
fn hello_world_complex() {
let mut brainfuck = Brainfuck::new(
">++++++++[-<+++++++++>]<.>>+>-[+]++>++>+++[>[->+++<<+++>]<<]\
>-----.>->+++..+++.>-.<<+[>[+>+]>>]<--------------.>>.+++.---\
---.--------.>+.>+.",
);
let mut output = Vec::new();
brainfuck.run(&mut io::empty(), &mut output).unwrap();
assert_eq!("Hello World!\n", String::from_utf8(output).unwrap());
}
}
|
#![allow(unused_variables)]
extern crate num_traits;
extern crate rand;
extern crate image;
#[macro_use]
extern crate derive_new;
#[cfg(feature="gui")]
extern crate minifb;
pub mod vec3;
pub mod ray;
pub mod hitable;
pub mod hitable_list;
pub mod sphere;
pub mod moving_sphere;
pub mod camera;
pub mod util;
pub mod material;
pub mod aabb;
pub mod bvh;
pub mod texture;
pub mod perlin;
pub mod aarect;
pub mod hbox;
// pub mod constant_medium;
pub mod onb;
pub mod pdf;
pub mod core;
pub mod scene;
pub mod output;
pub use vec3::*;
pub use ray::*;
pub use hitable::*;
pub use hitable_list::*;
pub use sphere::*;
pub use moving_sphere::*;
pub use camera::*;
pub use util::*;
pub use material::*;
pub use aabb::*;
pub use bvh::*;
pub use texture::*;
pub use perlin::*;
pub use aarect::*;
pub use hbox::*;
// pub use constant_medium::*;
pub use onb::*;
pub use pdf::*;
pub use scene::*;
pub use output::*;
pub use core::*;
macro_rules! perrln {
($($arg:tt)*) => ({
use std::io::{Write, stderr};
writeln!(&mut stderr(), $($arg)*).ok();
})
}
|
#[cfg(test)]
mod test;
use std::convert::TryInto;
use liblumen_alloc::erts::exception;
use liblumen_alloc::erts::process::Process;
use liblumen_alloc::erts::term::prelude::*;
use crate::runtime::time::{monotonic, system, Unit};
#[native_implemented::function(erlang:time_offset/1)]
pub fn result(process: &Process, unit: Term) -> exception::Result<Term> {
let unit_unit: Unit = unit.try_into()?;
let system_time = system::time_in_unit(unit_unit);
let monotonic_time = monotonic::time_in_unit(unit_unit);
let term = process.integer(system_time - monotonic_time);
Ok(term)
}
|
#[doc = "Reader of register PCROP1ASR"]
pub type R = crate::R<u32, super::PCROP1ASR>;
#[doc = "Reader of field `PCROP1A_STRT`"]
pub type PCROP1A_STRT_R = crate::R<u8, u8>;
impl R {
#[doc = "Bits 0:7 - PCROP1A area start offset"]
#[inline(always)]
pub fn pcrop1a_strt(&self) -> PCROP1A_STRT_R {
PCROP1A_STRT_R::new((self.bits & 0xff) as u8)
}
}
|
use crate::{HdbError, HdbResult};
// Here we list all those parts that are or should be implemented by this
// driver. ABAP related stuff and "reserved" numbers is omitted.
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum PartKind {
Command = 3, // SQL Command Data
ResultSet = 5, // Tabular resultset data
Error = 6, // Error information
StatementId = 10, // Prepared statement identifier
TransactionId = 11, // Transaction identifier
ExecutionResult = 12, // Number of affected rows of dml statement
ResultSetId = 13, // Identifier of resultset
TopologyInformation = 15, // Topology information
TableLocation = 16, // Location of table data
ReadLobRequest = 17, // Request data of READLOB message
ReadLobReply = 18, // Reply data of READLOB message
CommandInfo = 27, // Command information
WriteLobRequest = 28, // Request data of WRITELOB message
ClientContext = 29, // Client context
WriteLobReply = 30, // Reply data of WRITELOB message
Parameters = 32, // Parameter data
Authentication = 33, // Authentication data
SessionContext = 34, // Session context information
StatementContext = 39, // Statement visibility context
PartitionInformation = 40, // Table partitioning information
OutputParameters = 41, // Output parameter data
ConnectOptions = 42, // Connect options
CommitOptions = 43, // Commit options
FetchOptions = 44, // Fetch options
FetchSize = 45, // Number of rows to fetch
ParameterMetadata = 47, // Parameter metadata (type and length information)
ResultSetMetadata = 48, // Result set metadata (type = =, name, information)
FindLobRequest = 49, // Request data of FINDLOB message // TODO is missing
FindLobReply = 50, // Reply data of FINDLOB message // TODO is missing
ClientInfo = 57, // Client information values
TransactionFlags = 64, // Transaction handling flags
DbConnectInfo = 67, // Part of redirect response
LobFlags = 68, // LOB flags
ResultsetOptions = 69, // Additional context data for result sets
XatOptions = 70, // XA transaction information (XA transaction ID)
SessionVariable = 71, // undocumented
WorkloadReplayContext = 72, // undocumented
SQLReplyOptions = 73, // undocumented
PrintOptions = 74, // undocumented
}
impl PartKind {
pub fn from_i8(val: i8) -> HdbResult<Self> {
match val {
3 => Ok(Self::Command),
5 => Ok(Self::ResultSet),
6 => Ok(Self::Error),
10 => Ok(Self::StatementId),
11 => Ok(Self::TransactionId),
12 => Ok(Self::ExecutionResult),
13 => Ok(Self::ResultSetId),
15 => Ok(Self::TopologyInformation),
16 => Ok(Self::TableLocation),
17 => Ok(Self::ReadLobRequest),
18 => Ok(Self::ReadLobReply),
27 => Ok(Self::CommandInfo),
28 => Ok(Self::WriteLobRequest),
29 => Ok(Self::ClientContext),
30 => Ok(Self::WriteLobReply),
32 => Ok(Self::Parameters),
33 => Ok(Self::Authentication),
34 => Ok(Self::SessionContext),
39 => Ok(Self::StatementContext),
40 => Ok(Self::PartitionInformation),
41 => Ok(Self::OutputParameters),
42 => Ok(Self::ConnectOptions),
43 => Ok(Self::CommitOptions),
44 => Ok(Self::FetchOptions),
45 => Ok(Self::FetchSize),
47 => Ok(Self::ParameterMetadata),
48 => Ok(Self::ResultSetMetadata),
49 => Ok(Self::FindLobRequest),
50 => Ok(Self::FindLobReply),
57 => Ok(Self::ClientInfo),
64 => Ok(Self::TransactionFlags),
67 => Ok(Self::DbConnectInfo),
68 => Ok(Self::LobFlags),
69 => Ok(Self::ResultsetOptions),
70 => Ok(Self::XatOptions),
71 => Ok(Self::SessionVariable),
72 => Ok(Self::WorkloadReplayContext),
73 => Ok(Self::SQLReplyOptions),
74 => Ok(Self::PrintOptions),
_ => Err(HdbError::ImplDetailed(format!(
"PartKind {val} not implemented"
))),
}
}
}
|
use codeframe::{Codeframe, Color};
use k9::*;
#[test]
fn simple_capture() {
super::setup_test_env();
let raw_lines = "let a: i64 = 12;".to_owned();
let codeframe = Codeframe::new(raw_lines, 1).set_color(Color::Red).capture();
assert_matches_inline_snapshot!(
format!("\n{}", codeframe.expect("must be present")),
"
[31m1 | let a: i64 = 12;[0m
"
);
let raw_lines = "macro_rules! test_simple_style {
($string:expr, $style:ident) => {
#[test]
fn $style() {
assert_eq!(
s.$style().to_string(),
ansi_term::Style::new().$style().paint(s).to_string()
)
}
};
}"
.to_owned();
let codeframe = Codeframe::new(raw_lines, 5).set_color(Color::Red).capture();
assert_matches_inline_snapshot!(
format!("\n{}", codeframe.expect("must be present")),
"
[2m3 | #[test][0m
[2m4 | fn $style() {[0m
[31m5 | assert_eq!([0m
[31m6 | s.$style().to_string(),[0m
[31m7 | ansi_term::Style::new().$style().paint(s).to_string()[0m
[31m8 | )[0m
"
);
let raw_lines = "macro_rules! test_simple_style {
($string:expr, $style:ident) => {
#[test]
fn $style() {
assert_eq!(
s.$style().to_string(),
ansi_term::Style::new().$style().paint(s).to_string()
)
}
};
}"
.to_owned();
let codeframe = Codeframe::new(raw_lines, 5).capture();
assert_matches_inline_snapshot!(
format!("\n{}", codeframe.expect("must be present")),
"
[2m3 | #[test][0m
[2m4 | fn $style() {[0m
[31m5 | assert_eq!([0m
[31m6 | s.$style().to_string(),[0m
[31m7 | ansi_term::Style::new().$style().paint(s).to_string()[0m
[31m8 | )[0m
"
);
}
#[test]
fn out_of_bound_line_number() {
super::setup_test_env();
let raw_lines = "let a: i64 = 12;".to_owned();
let codeframe = Codeframe::new(raw_lines, 2)
.set_color(Color::Black)
.capture();
assert_matches_inline_snapshot!(
format!("\n{}", codeframe.expect("must be present")),
"
[2m1 | let a: i64 = 12;[0m
"
);
}
|
use crate::models::manufacturer::Manufacturer;
use serde::{Deserialize, Serialize};
#[derive(Deserialize, Serialize, Debug)]
pub struct LauncherCommon {
pub id: i32,
}
#[derive(Deserialize, Serialize, Debug)]
pub struct LauncherCommonConfiguration {
pub id: i32,
pub launch_library_id: Option<i32>,
pub url: String,
pub name: String,
pub family: String,
pub full_name: String,
pub variant: String,
}
#[derive(Deserialize, Serialize, Debug)]
pub struct Launcher {
pub id: i32,
pub launch_library_id: Option<i32>,
pub url: String,
pub name: String,
pub description: String,
pub family: String,
pub full_name: String,
pub manufacturer: Manufacturer,
pub variant: String,
pub alias: String,
pub min_stage: String,
pub max_stage: String,
pub length: Option<f32>,
pub diameter: Option<f32>,
pub maiden_flight: String,
pub launch_mass: i32,
pub leo_capacity: Option<i32>,
pub gto_capacity: Option<i32>,
pub to_thrust: i32,
pub image_url: String,
pub wiki_url: Option<String>,
pub total_launch_count: i32,
pub consecutive_successful_launches: i32,
pub successful_launches: i32,
pub failed_launches: i32,
pub pending_launches: i32,
}
|
use std::error::Error;
use std::path::PathBuf;
use structopt::StructOpt;
use serde::Serialize;
#[derive(StructOpt, Debug)]
#[structopt(name = "basic", set_term_width(80))]
struct CliOptions {
/// File name for the input CSV file
#[structopt(short, long, parse(from_os_str), display_order(10))]
input: PathBuf,
/// File name for the output CSV file
#[structopt(short, long, parse(from_os_str), display_order(11))]
output: PathBuf,
/// Your key for accessing locationiq.com
#[structopt(short, long, display_order(20))]
key: String,
/// Street input column (0-indexed or header name)
///
/// Street (input) column in the CSV file, specified either as 0-indexed number or as the text of the column header
#[structopt(short, long, display_order(50))]
street: String,
/// Postalcode input column (0-indexed or header name)
///
/// Postal code (input) column in the CSV file, specified either as 0-indexed number or as the text of the column header
#[structopt(short, long, display_order(51))]
postalcode: String,
/// City input column (0-indexed or header name)
///
/// City (input) column in the CSV file, specified either as 0-indexed number or as the text of the column header
#[structopt(short, long, display_order(52))]
city: String,
/// Country input column (0-indexed or header name)
///
/// Country (input) column in the CSV file, specified either as 0-indexed number or as the text of the column header
#[structopt(short = "y", long, display_order(53))]
country: String,
/// Latitude output column (0-indexed or header name)
///
/// Latitude output column in the CSV file, specified either as 0-indexed number or as the text of the column header.
/// Note that this column must already be present in the input CSV file (can be empty) and that any contents
/// in the corresponding fields will be overwritten
#[structopt(short = "t", long, display_order(70))]
lat: String,
/// Longitude output column (0-indexed or header name)
///
/// Longitude output column in the CSV file, specified either as 0-indexed number or as the text of the column header.
/// Note that this column must already be present in the input CSV file (can be empty) and that any contents
/// in the corresponding fields will be overwritten
#[structopt(short = "g", long, display_order(71))]
lng: String,
// TODO:
// - make wait between two requests to locationiq.com configurable (currently hardcoded to 2sec)
// - give possibility to add the output columns rather than having them already be present in the input file
}
#[derive(Debug)]
struct Columns {
street: usize,
postalcode: usize,
city: usize,
country: usize,
lat: usize,
lng: usize,
}
/* Shortcut macro for
let street = opts.street.parse::<usize>().or( headers
.iter()
.position(|s| s == opts.street)
.ok_or("Header columns for street not found"))?;
*/
macro_rules! let_num_or_header {
($i:ident = $o:expr, $h:expr) => {
let $i = $o.$i.parse::<usize>().or( $h
.iter()
.position(|s| s == $o.$i)
.ok_or( concat!("Header columns for ", stringify!($i), " not found") ))?;
};
}
impl Columns {
fn from_opts_and_header(
opts: &CliOptions,
headers: &csv::StringRecord,
) -> Result<Self, Box<dyn Error>> {
let_num_or_header!(street = opts, headers);
let_num_or_header!(postalcode = opts, headers);
let_num_or_header!(city = opts, headers);
let_num_or_header!(country = opts, headers);
let_num_or_header!(lat = opts, headers);
let_num_or_header!(lng = opts, headers);
Ok(Self { street, postalcode, city, country, lat, lng })
}
}
#[derive(Serialize, Debug)]
struct SearchQuery {
key: String,
street: String,
postalcode: String,
city: String,
country: String,
format: String
}
fn main() -> Result<(), Box<dyn Error>> {
let opts = CliOptions::from_args();
//let input_file = File::open(&opts.input)?;
//let mut csv_reader = csv::Reader::from_reader(BufReader::new(input_file));
let mut csv_reader = csv::Reader::from_path(&opts.input)?;
let headers = csv_reader.headers()?;
let columns = Columns::from_opts_and_header(&opts, headers)?;
//println!("{:?}", &columns);
let mut csv_writer = csv::WriterBuilder::new()
.from_path(&opts.output)?;
csv_writer.write_record(headers)?;
let http_client = reqwest::blocking::Client::new();
for result in csv_reader.records() {
let record = result?;
std::thread::sleep(std::time::Duration::from_millis(2000));
println!("Processing line {}", &record.position().unwrap().line());
let search_query = SearchQuery {
key: opts.key.clone(),
street: record.get(columns.street).unwrap_or("").to_string(),
postalcode: record.get(columns.postalcode).unwrap_or("").to_string(),
city: record.get(columns.city).unwrap_or("").to_string(),
country: record.get(columns.country).unwrap_or("").to_string(),
format: String::from("json")
};
let url = "https://eu1.locationiq.com/v1/search.php";
let res = http_client.get(url).query(&search_query).send()?;
let text = res.text()?;
let result : serde_json::Value = serde_json::from_str( &text )?;
let lat = result[0]["lat"].as_str().unwrap_or("");
let lng = result[0]["lon"].as_str().unwrap_or("");
if lat.is_empty() || lng.is_empty() {
println!("No result for: {:?}", search_query);
println!("{}", &text);
}
let mut record_out = csv::StringRecord::new();
for i in 0..record.len() {
if i == columns.lat {
record_out.push_field(&format!("{}", &lat));
}
else if i == columns.lng {
record_out.push_field(&format!("{}", &lng));
}
else {
record_out.push_field(record.get(i).unwrap_or(""));
}
}
csv_writer.write_record(&record_out)?;
csv_writer.flush()?;
}
csv_writer.flush()?;
Ok(())
}
|
use ili9163c;
use gpio_traits::pin::{Output, PinState};
use std::cell::Cell;
use std::rc::Rc;
pub struct Pin {
state: Rc<Cell<PinState>>,
}
impl Pin {
pub fn new(state: Rc<Cell<PinState>>) -> Self {
Pin { state: state }
}
}
impl Output for Pin {
fn high(&mut self) {
self.state.set(PinState::High);
}
fn low(&mut self) {
self.state.set(PinState::Low);
}
}
|
use gdk_pixbuf::{Pixbuf, Colorspace};
use std::{cell::RefCell, rc::Rc};
use nanocv::{ImgBuf, ImgSize, Img};
use crate::message::Rgba;
pub fn create_pixbuf(width: usize, height: usize) -> Pixbuf {
Pixbuf::new(
Colorspace::Rgb, true, 8, width as i32, height as i32
).expect("No enough memory to create pixbuf.")
}
pub fn update_pixbuf(
image: &ImgBuf<Rgba>,
pixbuf: Rc<RefCell<Pixbuf>>,
) {
if pixbuf_size(pixbuf.clone()) != image.size() {
pixbuf.replace(create_pixbuf(image.width(), image.height()));
}
copy_rgba_to_pixbuf(image, &pixbuf.borrow());
}
fn pixbuf_size(pixbuf: Rc<RefCell<Pixbuf>>) -> ImgSize {
let inner: &Pixbuf = &pixbuf.borrow();
ImgSize::new(inner.get_width() as usize, inner.get_height() as usize)
}
fn copy_rgba_to_pixbuf(image: &ImgBuf<Rgba>, pixbuf: &Pixbuf) {
let pixbuf_data = unsafe { pixbuf.get_pixels() };
let (w, h) = (image.width(), image.height());
let stride = pixbuf.get_rowstride() as usize;
for line in 0..h {
let line_pixels = image.line_ref(line);
let buf_pixels = &mut pixbuf_data[line*stride..line*stride + w*4];
let mut offset = 0;
while offset < buf_pixels.len() {
let pixel = line_pixels[offset/4];
let target = &mut buf_pixels[offset .. (offset + 4)];
target[0] = pixel[0];
target[1] = pixel[1];
target[2] = pixel[2];
target[3] = pixel[3];
offset += 4;
}
}
}
pub fn horizontal_line(pixbuf: &Pixbuf, line: isize) {
if line >= 0 && line < pixbuf.get_height() as isize {
let line = line as usize;
let width = pixbuf.get_width() as usize;
let pixbuf_data = unsafe { pixbuf.get_pixels() };
let stride = pixbuf.get_rowstride() as usize;
let line_pixels = &mut pixbuf_data[line*stride..line*stride + width*4];
let mut offset = 0;
while offset < line_pixels.len() {
invert_pixel(line_pixels, offset);
offset += 4;
}
}
}
pub fn vertical_line(pixbuf: &Pixbuf, column: isize) {
if column >= 0 && column < pixbuf.get_width() as isize {
let column = column as usize;
let pixbuf_data = unsafe { pixbuf.get_pixels() };
let pixel_offset = column*4;
let stride = pixbuf.get_rowstride() as usize;
for line in 0..pixbuf.get_height() as usize {
let offset = line*stride + pixel_offset;
invert_pixel(pixbuf_data, offset);
}
}
}
fn invert_pixel(data: &mut [u8], offset: usize) {
data[offset + 0] = 255 - data[offset + 0];
data[offset + 1] = 255 - data[offset + 1];
data[offset + 2] = 255 - data[offset + 2];
} |
// Copyright 2021 Datafuse Labs.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::sync::Arc;
use common_exception::Result;
use common_meta_app::principal::PrincipalIdentity;
use common_sql::plans::GrantRolePlan;
use common_users::RoleCacheManager;
use common_users::UserApiProvider;
use crate::interpreters::Interpreter;
use crate::pipelines::PipelineBuildResult;
use crate::sessions::QueryContext;
use crate::sessions::TableContext;
#[derive(Debug)]
pub struct GrantRoleInterpreter {
ctx: Arc<QueryContext>,
plan: GrantRolePlan,
}
impl GrantRoleInterpreter {
pub fn try_create(ctx: Arc<QueryContext>, plan: GrantRolePlan) -> Result<Self> {
Ok(GrantRoleInterpreter { ctx, plan })
}
}
#[async_trait::async_trait]
impl Interpreter for GrantRoleInterpreter {
fn name(&self) -> &str {
"GrantRoleInterpreter"
}
#[tracing::instrument(level = "debug", skip(self), fields(ctx.id = self.ctx.get_id().as_str()))]
async fn execute2(&self) -> Result<PipelineBuildResult> {
let plan = self.plan.clone();
let tenant = self.ctx.get_tenant();
let user_mgr = UserApiProvider::instance();
// TODO: check privileges
// Check if the grant role exists.
user_mgr.get_role(&tenant, plan.role.clone()).await?;
match plan.principal {
PrincipalIdentity::User(user) => {
user_mgr
.grant_role_to_user(&tenant, user, plan.role)
.await?;
}
PrincipalIdentity::Role(role) => {
user_mgr
.grant_role_to_role(&tenant, &role, plan.role)
.await?;
}
}
RoleCacheManager::instance().force_reload(&tenant).await?;
Ok(PipelineBuildResult::create())
}
}
|
use std::ffi::CStr;
use ash::vk;
use super::{
error::{GraphicsError, GraphicsResult},
RendererConfig,
};
const VULKAN_VERSION: (u32, u32) = (1, 2);
pub(crate) fn get_candidates(
instance: &ash::Instance,
) -> GraphicsResult<Vec<(vk::PhysicalDevice, vk::PhysicalDeviceProperties, bool)>> {
let phys_devs = unsafe { instance.enumerate_physical_devices() }?;
let mut candidates = Vec::new();
for device in phys_devs {
let properties = unsafe { instance.get_physical_device_properties(device) };
let extensions = unsafe { instance.enumerate_device_extension_properties(device)? };
let ext_memory_budget_supported = extensions.iter().any(|ext| {
let c_str = unsafe { CStr::from_ptr(ext.extension_name.as_ptr()) };
c_str.to_str().unwrap() == "VK_EXT_memory_budget"
});
#[cfg(debug_assertions)]
{
let name = String::from(
unsafe { CStr::from_ptr(properties.device_name.as_ptr()) }
.to_str()
.unwrap(),
);
log::info!(
"GPU detected: {} ({:08X}:{:08X})",
name,
properties.vendor_id,
properties.device_id
);
if ext_memory_budget_supported {
log::info!(" supports VK_EXT_memory_budget");
}
}
if vk::api_version_major(properties.api_version) != VULKAN_VERSION.0
|| vk::api_version_minor(properties.api_version) < VULKAN_VERSION.1
{
continue;
}
candidates.push((device, properties, ext_memory_budget_supported));
}
Ok(candidates)
}
pub(crate) fn select_physical_device(
instance: &ash::Instance,
config: Option<&RendererConfig>,
) -> GraphicsResult<(vk::PhysicalDevice, vk::PhysicalDeviceProperties, bool)> {
let override_ids = config
.map(|cfg| cfg.gpu_vendor_id.zip(cfg.gpu_device_id))
.unwrap_or(None);
let candidates = get_candidates(instance)?;
if candidates.is_empty() {
return Err(GraphicsError::NoSuitableGpu);
}
if let Some((vendor, device)) = override_ids {
let dev = candidates
.iter()
.find(|d| d.1.vendor_id == vendor && d.1.device_id == device);
if let Some(dev) = dev {
return Ok(*dev);
} else {
log::warn!("Override GPU with id {:08X}:{:08X} not found or not suitable, using default device", vendor, device);
}
}
Ok(*candidates.first().unwrap())
}
|
#![feature(plugin)]
#![plugin(rocket_codegen)]
extern crate rocket;
#[get("/")]
fn hello() -> &'static str {
"Hello, world!"
}
fn main() {
rocket::ignite().mount("/", routes![hello]).launch();
}
//extern crate dotenv;
//#[macro_use] extern crate rocket_contrib;
//#[macro_use] extern crate diesel;
//extern crate payment_api;
//extern crate r2d2;
//extern crate r2d2_diesel;
//
//mod schema;
//use diesel::prelude::*;
//use payment_api::*;
//use payment_api::models::User;
//use rocket_contrib::{Json, Value};
//
////#[post("/", data = "<user>")]
////fn create(user: Json<User>, connection: db::Connection) -> Json<User> {
//// let insert = User {..user.into_inner() };
//// Json(User::create(insert, &connection))
////}
//
////fn new_user(first_name: String, last_name: String, user_name: String, cell_number: i32,
//// cell_verified: bool, email: String, public_key: String, private_key: String,
//// eth_address: String) -> User {
//// let conn = establish_connection();
////
//// let new_user = create_user(&conn, first_name, last_name, user_name, cell_number,
//// cell_verified, email, private_key, public_key, eth_address);
////// println!("Saved person: {}", new_user.first_name);
//// new_user
////}
//
////#[get("/")]
////fn read(connection: db::Connection) -> Json<Value> {
//// Json(json!(User::read(&connection)))
////}
//
////#[put("/<id>", data = "<user>")]
////fn update(id: i32, user: Json<User>, connection: db::Connection) -> Json<Value> {
////
//// // todo fix this, update was not working, delete is not right
//// let update = User { id: Some(id), ..user.into_inner() };
//// Json(json!({
//// "success": User::delete(id, &connection)
//// }))
////}
////
////#[delete("/<id>")]
////fn delete(id: i32, connection: db::Connection) -> Json<Value> {
//// Json(json!({
//// "success": User::delete(id, &connection)
//// }))
////}
//
//fn main() {
//// rocket::ignite()
////// .mount("/user", routes![update, delete])
////// .mount("/users", routes![read])
//// .manage(db::connect())
//// .launch();
//}
|
extern crate self as fuzzcheck;
#[cfg(feature = "serde_json_serializer")]
use serde::{Deserialize, Serialize};
/// An abstract syntax tree.
///
#[cfg_attr(
feature = "serde_json_serializer",
doc = "It can be serialized with [`SerdeSerializer`](crate::SerdeSerializer) on crate feature `serde_json_serializer`"
)]
#[cfg_attr(
not(feature = "serde_json_serializer"),
doc = "It can be serialized with `SerdeSerializer` on crate feature `serde_json_serializer`"
)]
#[cfg_attr(feature = "serde_json_serializer", derive(Serialize, Deserialize))]
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum AST {
#[doc(hidden)]
Token(char),
#[doc(hidden)]
Sequence(Vec<AST>),
}
impl AST {
#[no_coverage]
pub fn generate_string_in(&self, string: &mut String) {
match self {
AST::Token(c) => {
string.push(*c);
}
AST::Sequence(asts) => {
for ast in asts {
ast.generate_string_in(string);
}
}
}
}
/// Converts the AST to its `String` representation
#[allow(clippy::inherent_to_string)]
#[no_coverage]
pub fn to_string(&self) -> String {
let mut s = String::with_capacity(64);
self.generate_string_in(&mut s);
s
}
}
|
use crate::eos_formats::format_action;
use crate::proc_macro::TokenStream;
use quote::{quote, quote_spanned};
use syn::spanned::Spanned;
use syn::{self, parse_macro_input, ItemFn};
pub fn action(_args: TokenStream, input: TokenStream) -> TokenStream {
let input = parse_macro_input!(input as ItemFn);
let ident = &input.sig.ident;
let action_struct = format_action(ident);
let mut action_fields = Vec::new();
let mut fields_setup = Vec::new();
for input_field in &input.sig.inputs {
match input_field {
syn::FnArg::Typed(arg) => {
let field = &arg.pat;
let ty = &arg.ty;
action_fields.push(quote_spanned!(field.span()=> #field : #ty));
fields_setup.push(quote_spanned!(ty.span()=> let #field = self.#field));
}
_ => action_fields.push(quote_spanned!(input_field.span()=>
compile_error!("receiver argument (&self) is not allowed"))),
}
}
let action_block = &input.block;
let output = quote! {
#[derive(eosio_cdt::eos::Deserialize)]
pub struct #action_struct {
#(#action_fields),*
}
impl eosio_cdt::Action for #action_struct {
const NAME: eosio_cdt::eos::Name =
eosio_cdt::eos::name_from_str(stringify!(#ident));
fn execute(self, contract: &eosio_cdt::Contract) {
#(#fields_setup);*;
#action_block
}
}
};
output.into()
}
|
use std::collections::HashSet;
use proconio::{input, marker::Chars};
fn main() {
input! {
n: usize,
s: [Chars; n],
};
let mut set = HashSet::new();
for s in s {
let mut t = s.clone();
t.reverse();
if set.contains(&s) || set.contains(&t) {
continue;
}
set.insert(s);
}
println!("{}", set.len());
}
|
//! Streaming async HTTP 1.1 parser.
//!
//! At its core HTTP is a stateful RPC protocol, where a client and server
//! communicate with one another by encoding and decoding messages between them.
//!
//! - `client` encodes HTTP requests, and decodes HTTP responses.
//! - `server` decodes HTTP requests, and encodes HTTP responses.
//!
//! A client always starts the HTTP connection. The lifetime of an HTTP
//! connection looks like this:
//!
//! ```txt
//! 1. encode 2. decode
//! \ /
//! -> request ->
//! client server
//! <- response <-
//! / \
//! 4. decode 3. encode
//! ```
//!
//! See also [`async-tls`](https://docs.rs/async-tls),
//! [`async-std`](https://docs.rs/async-std).
//!
//! # Example
//!
//! __HTTP client__
//!
//! ```no_run
//! use async_std::net::TcpStream;
//! use http_types::{Method, Request, Url};
//!
//! #[async_std::main]
//! async fn main() -> http_types::Result<()> {
//! let stream = TcpStream::connect("127.0.0.1:8080").await?;
//!
//! let peer_addr = stream.peer_addr()?;
//! println!("connecting to {}", peer_addr);
//! let url = Url::parse(&format!("http://{}/foo", peer_addr))?;
//!
//! let req = Request::new(Method::Get, url);
//! let res = async_h1::connect(stream.clone(), req).await?;
//! println!("{:?}", res);
//!
//! Ok(())
//! }
//! ```
//!
//! __HTTP Server__
//!
//! ```no_run
//! use async_std::net::{TcpStream, TcpListener};
//! use async_std::prelude::*;
//! use async_std::task;
//! use http_types::{Response, StatusCode};
//!
//! #[async_std::main]
//! async fn main() -> http_types::Result<()> {
//! // Open up a TCP connection and create a URL.
//! let listener = TcpListener::bind(("127.0.0.1", 8080)).await?;
//! let addr = format!("http://{}", listener.local_addr()?);
//! println!("listening on {}", addr);
//!
//! // For each incoming TCP connection, spawn a task and call `accept`.
//! let mut incoming = listener.incoming();
//! while let Some(stream) = incoming.next().await {
//! let stream = stream?;
//! task::spawn(async {
//! if let Err(err) = accept(stream).await {
//! eprintln!("{}", err);
//! }
//! });
//! }
//! Ok(())
//! }
//!
//! // Take a TCP stream, and convert it into sequential HTTP request / response pairs.
//! async fn accept(stream: TcpStream) -> http_types::Result<()> {
//! println!("starting new connection from {}", stream.peer_addr()?);
//! async_h1::accept(stream.clone(), |_req| async move {
//! let mut res = Response::new(StatusCode::Ok);
//! res.insert_header("Content-Type", "text/plain");
//! res.set_body("Hello");
//! Ok(res)
//! })
//! .await?;
//! Ok(())
//! }
//! ```
#![forbid(unsafe_code)]
#![deny(missing_debug_implementations, nonstandard_style, rust_2018_idioms)]
#![warn(missing_docs, missing_doc_code_examples, unreachable_pub)]
#![cfg_attr(test, deny(warnings))]
#![allow(clippy::if_same_then_else)]
#![allow(clippy::len_zero)]
#![allow(clippy::match_bool)]
#![allow(clippy::unreadable_literal)]
/// The maximum amount of headers parsed on the server.
const MAX_HEADERS: usize = 128;
/// The maximum length of the head section we'll try to parse.
/// See: https://nodejs.org/en/blog/vulnerability/november-2018-security-releases/#denial-of-service-with-large-http-headers-cve-2018-12121
const MAX_HEAD_LENGTH: usize = 8 * 1024;
mod body_encoder;
mod chunked;
mod date;
mod read_notifier;
pub mod client;
pub mod server;
use async_std::io::Cursor;
use body_encoder::BodyEncoder;
pub use client::connect;
pub use server::{accept, accept_with_opts, ServerOptions};
#[derive(Debug)]
pub(crate) enum EncoderState {
Start,
Head(Cursor<Vec<u8>>),
Body(BodyEncoder),
End,
}
/// like ready! but early-returns the Poll<Result<usize>> early in all situations other than Ready(Ok(0))
#[macro_export]
macro_rules! read_to_end {
($expr:expr) => {
match $expr {
Poll::Ready(Ok(0)) => (),
other => return other,
}
};
}
|
pub use VkImageType::*;
#[repr(u32)]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum VkImageType {
VK_IMAGE_TYPE_1D = 0,
VK_IMAGE_TYPE_2D = 1,
VK_IMAGE_TYPE_3D = 2,
}
|
// Copyright 2020-2021, The Tremor Team
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::fmt::Display;
/// A shared error for common functions
#[derive(Debug)]
pub enum Error {
/// Failed to open a File
FileOpen(std::io::Error, String),
/// Failed to create a File
FileCreate(std::io::Error, String),
/// Failed to canonicalize a path
FileCanonicalize(std::io::Error, String),
/// Failed to change working directory
Cwd(std::io::Error, String),
}
impl Display for Error {
fn fmt(&self, w: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Error::FileOpen(e, f) => write!(w, "Failed to open file `{}`: {}", f, e),
Error::FileCreate(e, f) => write!(w, "Failed to create file `{}`: {}", f, e),
Error::FileCanonicalize(e, f) => {
write!(w, "Failed to canonicalize path `{}`: {}", f, e)
}
Error::Cwd(e, f) => write!(w, "Failed to change working directory `{}`: {}", f, e),
}
}
}
impl std::error::Error for Error {}
#[doc(hidden)]
/// Optimized try
#[macro_export]
macro_rules! stry {
($e:expr) => {
match $e {
::std::result::Result::Ok(val) => val,
::std::result::Result::Err(err) => return ::std::result::Result::Err(err),
}
};
}
|
//! Poor man's language analyzer.
use keywords::KeywordPriority;
use std::collections::HashMap;
use std::sync::OnceLock;
mod keywords;
const LOWEST_PRIORITY: usize = 1000usize;
/// Display priority of the line.
///
/// Lower is better, the better results will be displayed first.
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct Priority(usize);
impl Priority {
pub fn as_i32(self) -> i32 {
self.0 as i32
}
}
impl Default for Priority {
fn default() -> Self {
Self(LOWEST_PRIORITY)
}
}
impl From<usize> for Priority {
fn from(priority: usize) -> Self {
Self(priority)
}
}
/// Returns a list of comment prefix for a source file.
///
/// # Argument
///
/// - `ext`: the extension of a file, e.g., `rs`.
pub fn get_comment_syntax(ext: &str) -> &[&str] {
static LANGUAGE_COMMENT_TABLE: OnceLock<HashMap<&str, Vec<&str>>> = OnceLock::new();
let table = LANGUAGE_COMMENT_TABLE.get_or_init(|| {
serde_json::from_str(include_str!("../../../scripts/dumb_jump/comments_map.json"))
.expect("Wrong path for comments_map.json")
});
table
.get(ext)
.unwrap_or_else(|| table.get("*").expect("`*` entry exists; qed"))
}
/// Return `true` if the line is a comment.
pub fn is_comment(line: &str, file_ext: &str) -> bool {
get_comment_syntax(file_ext)
.iter()
.any(|comment_syntax| line.trim_start().starts_with(comment_syntax))
}
// TODO: More general precise reference resolution, tree-sitter?
/// Returns a tuple of (ref_kind, kind_weight) given the pattern and source file extension.
pub fn resolve_reference_kind(pattern: impl AsRef<str>, file_ext: &str) -> (&'static str, usize) {
let pattern = pattern.as_ref();
let maybe_more_precise_kind = match file_ext {
"rs" => {
let pattern = pattern.trim_start();
// use foo::bar;
// pub(crate) use foo::bar;
if pattern.starts_with("use ")
|| (pattern.starts_with("pub")
&& pattern
.split_ascii_whitespace()
.take(2)
.last()
.map(|e| e == "use")
.unwrap_or(false))
{
Some(("use", 1))
} else if pattern.starts_with("impl") {
Some(("impl", 2))
} else {
None
}
}
_ => None,
};
maybe_more_precise_kind.unwrap_or(("refs", 100))
}
// TODO: language keyword lookup
//
// https://github.com/e3b0c442/keywords#rust-146-53-keywords
/// Calculates the weight of a specific pattern.
pub fn calculate_pattern_priority(pattern: impl AsRef<str>, file_ext: &str) -> Option<Priority> {
let weigher = match file_ext {
"erl" => keywords::Erlang::keyword_priority,
"go" => keywords::Golang::keyword_priority,
"rs" => keywords::Rust::keyword_priority,
"vim" => keywords::Viml::keyword_priority,
_ => return None,
};
// Try the first 3 items because:
//
// 1. blines provider prepends the line number to the original line and the language bonus
// is mostly used in the blines provider.
// 2. Languages like Rust has the visibility before the commen keyword(fn, struct, ...).
pattern
.as_ref()
.split_whitespace()
.take(3)
.find_map(weigher)
.map(Into::into)
}
|
use std::io;
use std::io::Write;
use std::fs::File;
use rustypawn::ThinkInfo;
use rustypawn::MoveTrait;
use rustypawn::Game;
use rustypawn::MAX_DEPTH;
use rustypawn::make_move_algebraic;
use rustypawn::think;
struct Comms {
file: Option<File>
}
impl Comms {
pub fn new(name: Option<&str>) -> Comms {
Comms {
file: match name {
Some(n) => Some(File::create(n).unwrap()),
None => None
}
}
}
fn write(self: &mut Comms, prefix: &str, msg: &str) {
match &mut self.file {
Some(f) => {
f.write_all(prefix.as_bytes()).unwrap();
f.write_all(msg.as_bytes()).unwrap();
f.write_all(b"\n").unwrap();
},
None => {}
}
}
pub fn input(self: &mut Comms, msg: &str) {
self.write("> ", msg);
}
pub fn output<S: Into<String>>(self: &mut Comms, msg: S) {
let s = msg.into();
println!("{}", s);
self.write("< ", &s[..]);
}
pub fn fatal<S: Into<String>>(self: &mut Comms, msg: S) -> ! {
let s = msg.into();
self.write("! ", &s[..]);
panic!(s);
}
pub fn debug<S: Into<String>>(self: &mut Comms, msg: S) {
let s = msg.into();
self.write("- ", &s[..]);
}
}
impl ThinkInfo for Comms {
fn think_info(self: &mut Comms, depth: usize, score: isize, mate_in: isize, node_count: usize, millis: u64, moves: &Vec<String>) {
let nps = if millis > 0 { 1000 * node_count as u64 / millis } else { 0 };
let msg = format!("info depth {} score {} nodes {} time {} nps {} pv {}",
depth, if mate_in != 0 { format!("mate {}", mate_in) } else { format!("cp {}", score) },
node_count, millis, nps, moves.join(" "));
self.output(msg);
}
}
fn main() {
let mut game = Game::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0").unwrap();
let mut comms = Comms::new(None);
// let mut comms = Comms::new("/tmp/rustypawn-0.4.log");
println!("Rustypawn");
loop {
let mut input = String::new();
match io::stdin().read_line(&mut input) {
Ok(0) => break,
Ok(_) => {
let line = input.trim();
comms.input(line);
let mut arg_iter = line.split_whitespace();
match arg_iter.next() {
Some("uci") => {
comms.output("id name rustypawn");
comms.output("id author Jan Marthedal Rasmussen");
comms.output("uciok");
},
Some("isready") => {
comms.output("readyok");
},
Some("position") => {
let fen = match arg_iter.next() {
Some("startpos") => {
// position startpos
// position startpos moves e2e4 e7e5
String::from("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0")
},
Some("fen") => {
// position fen rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w moves e2e4 e7e5
let mut fen_items: Vec<&str> = Vec::new();
loop {
match arg_iter.next() {
Some("moves") => break,
Some(s) => fen_items.push(s),
None => break
}
}
fen_items.join(" ")
},
Some(_) => comms.fatal("Unknown 'position' argument"),
_ => comms.fatal("Missing argument to 'position'")
};
game = match Game::from_fen(&fen[..]) {
Ok(g) => g,
Err(e) => comms.fatal(format!("Illegal fen string '{}' ({})", fen, e))
};
loop {
match arg_iter.next() {
Some("moves") => continue,
Some(s) => make_move_algebraic(&mut game, s),
None => break
}
}
},
Some("go") => {
let white_to_move = game.white_to_move();
let mut millis_to_think: u64 = 10 * 60 * 1000; // 10 minutes
let mut wtime: i32 = -1;
let mut btime: i32 = -1;
let mut movestogo: u64 = 0;
loop {
match arg_iter.next() {
Some("wtime") => {
match arg_iter.next() {
Some(s) => {
wtime = match s.parse::<i32>() {
Ok(n) => n,
_ => comms.fatal("Error parsing wtime")
};
if white_to_move && movestogo > 0 {
millis_to_think = wtime as u64 / movestogo;
}
},
None => comms.fatal("Missing wtime")
}
},
Some("btime") => {
match arg_iter.next() {
Some(s) => {
btime = match s.parse::<i32>() {
Ok(n) => n,
_ => comms.fatal("Error parsing btime")
};
if !white_to_move && movestogo > 0 {
millis_to_think = btime as u64 / movestogo;
}
},
None => comms.fatal("Missing btime")
}
},
Some("movestogo") => {
match arg_iter.next() {
Some(s) => {
movestogo = match s.parse::<u64>() {
Ok(n) => n,
_ => comms.fatal("Error parsing movestogo")
};
if white_to_move && wtime > 0 {
millis_to_think = wtime as u64 / movestogo;
} else if !white_to_move && btime > 0 {
millis_to_think = btime as u64 / movestogo;
}
},
None => comms.fatal("Missing movestogo")
}
},
Some("movetime") => {
match arg_iter.next() {
Some(s) => {
millis_to_think = match s.parse::<u64>() {
Ok(n) => n,
_ => comms.fatal("Error parsing movetime")
};
},
None => comms.fatal("Missing movetime")
}
},
Some(s) => comms.debug(format!("Ignore go argument '{}'", s)),
None => break
}
}
let mv = match think(&mut game, millis_to_think, MAX_DEPTH, &mut comms) {
Some(m) => m,
None => comms.fatal("No legal move")
};
comms.output(format!("bestmove {}", mv.to_algebraic()));
}
_ => continue
}
}
Err(error) => comms.fatal(format!("error: {}", error))
}
}
}
|
use std::{
pin::Pin,
task::{Context, Poll},
};
use futures::{ready, stream::BoxStream, Stream, StreamExt};
use generated_types::{read_response::Frame, ReadResponse};
/// Chunk given [`Frame`]s -- while preserving the order -- into [`ReadResponse`]s that shall at max have the
/// given `size_limit`, in bytes.
pub struct ChunkReadResponses {
inner: BoxStream<'static, Result<Frame, tonic::Status>>,
size_limit: usize,
finished: bool,
frames: Vec<Frame>,
/// Current size of `frames`, in bytes
frames_size: usize,
}
impl ChunkReadResponses {
/// Create new stream wrapper.
///
/// # Panic
/// Panics if `size_limit` is 0.
pub fn new<S>(inner: S, size_limit: usize) -> Self
where
S: Stream<Item = Result<Frame, tonic::Status>> + Send + 'static,
{
assert!(size_limit > 0, "zero size limit");
Self {
inner: inner.boxed(),
size_limit,
finished: false,
frames: Vec::default(),
frames_size: 0,
}
}
}
impl Stream for ChunkReadResponses {
type Item = Result<ReadResponse, tonic::Status>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
let this = &mut *self;
if this.finished {
return Poll::Ready(None);
}
loop {
match ready!(this.inner.poll_next_unpin(cx)) {
Some(Ok(frame)) => {
let fsize = frame_size(&frame);
if fsize > this.size_limit {
this.finished = true;
return Poll::Ready(Some(Err(tonic::Status::resource_exhausted(format!(
"Oversized frame in read response: frame_size={}, size_limit={}",
fsize, this.size_limit
)))));
}
// flush?
if this.frames_size + fsize > this.size_limit {
this.frames_size = fsize;
let mut tmp = vec![frame];
std::mem::swap(&mut tmp, &mut this.frames);
return Poll::Ready(Some(Ok(ReadResponse { frames: tmp })));
}
this.frames.push(frame);
this.frames_size += fsize;
}
Some(Err(e)) => {
return Poll::Ready(Some(Err(e)));
}
None => {
this.finished = true;
// final flush
if !this.frames.is_empty() {
this.frames_size = 0;
return Poll::Ready(Some(Ok(ReadResponse {
frames: std::mem::take(&mut this.frames),
})));
} else {
return Poll::Ready(None);
}
}
}
}
}
}
fn frame_size(frame: &Frame) -> usize {
frame
.data
.as_ref()
.map(|data| data.encoded_len())
.unwrap_or_default()
}
#[cfg(test)]
mod tests {
use futures::TryStreamExt;
use generated_types::influxdata::platform::storage::read_response::{
frame::Data, BooleanPointsFrame,
};
use super::*;
#[test]
#[should_panic(expected = "zero size limit")]
fn test_new_panics() {
ChunkReadResponses::new(futures::stream::empty(), 0);
}
#[tokio::test]
async fn test_ok() {
let frame1 = Frame {
data: Some(Data::BooleanPoints(BooleanPointsFrame {
timestamps: vec![1, 2, 3],
values: vec![false, true, false],
})),
};
let frame2 = Frame {
data: Some(Data::BooleanPoints(BooleanPointsFrame {
timestamps: vec![4],
values: vec![true],
})),
};
let fsize1 = frame_size(&frame1);
let fsize2 = frame_size(&frame2);
// no respones
assert_eq!(
ChunkReadResponses::new(futures::stream::empty(), 1)
.try_collect::<Vec<_>>()
.await
.unwrap(),
vec![],
);
// split
assert_eq!(
ChunkReadResponses::new(
futures::stream::iter([
Ok(frame1.clone()),
Ok(frame1.clone()),
Ok(frame2.clone()),
Ok(frame2.clone()),
Ok(frame1.clone()),
]),
fsize1 + fsize1 + fsize2,
)
.try_collect::<Vec<_>>()
.await
.unwrap(),
vec![
ReadResponse {
frames: vec![frame1.clone(), frame1.clone(), frame2.clone()],
},
ReadResponse {
frames: vec![frame2.clone(), frame1.clone()],
},
],
);
// single response
assert_eq!(
ChunkReadResponses::new(
futures::stream::iter(
[Ok(frame1.clone()), Ok(frame2.clone()), Ok(frame2.clone()),]
),
fsize1 + fsize2 + fsize2,
)
.try_collect::<Vec<_>>()
.await
.unwrap(),
vec![ReadResponse {
frames: vec![frame1.clone(), frame2.clone(), frame2.clone()],
},],
);
// multiple responses
assert_eq!(
ChunkReadResponses::new(
futures::stream::iter([
Ok(frame1.clone()),
Ok(frame1.clone()),
Ok(frame2.clone()),
Ok(frame2.clone()),
Ok(frame1.clone()),
Ok(frame1.clone()),
Ok(frame2.clone()),
]),
fsize1 + fsize1 + fsize2,
)
.try_collect::<Vec<_>>()
.await
.unwrap(),
vec![
ReadResponse {
frames: vec![frame1.clone(), frame1.clone(), frame2.clone()],
},
ReadResponse {
frames: vec![frame2.clone(), frame1.clone(), frame1],
},
ReadResponse {
frames: vec![frame2],
},
],
);
}
#[tokio::test]
async fn test_err_stream() {
let frame = Frame {
data: Some(Data::BooleanPoints(BooleanPointsFrame {
timestamps: vec![1, 2, 3],
values: vec![false, true, false],
})),
};
let fsize = frame_size(&frame);
// split
let res = ChunkReadResponses::new(
futures::stream::iter(vec![
Ok(frame.clone()),
Ok(frame.clone()),
Ok(frame.clone()),
Ok(frame.clone()),
Err(tonic::Status::internal("foo")),
Ok(frame.clone()),
]),
2 * fsize,
)
.collect::<Vec<_>>()
.await;
assert_eq!(res.len(), 4);
assert_eq!(
res[0].as_ref().unwrap(),
&ReadResponse {
frames: vec![frame.clone(), frame.clone()],
},
);
// error comes two frames early because the package wasn't full yet
assert_eq!(res[1].as_ref().unwrap_err().code(), tonic::Code::Internal,);
assert_eq!(res[1].as_ref().unwrap_err().message(), "foo",);
assert_eq!(
res[2].as_ref().unwrap(),
&ReadResponse {
frames: vec![frame.clone(), frame.clone()],
},
);
assert_eq!(
res[3].as_ref().unwrap(),
&ReadResponse {
frames: vec![frame],
},
);
}
#[tokio::test]
async fn test_err_oversized() {
let frame = Frame {
data: Some(Data::BooleanPoints(BooleanPointsFrame {
timestamps: vec![1, 2, 3],
values: vec![false, true, false],
})),
};
// split
let res = ChunkReadResponses::new(
futures::stream::iter([Ok(frame.clone()), Ok(frame.clone())]),
1,
)
.collect::<Vec<_>>()
.await;
assert_eq!(res.len(), 1);
assert_eq!(
res[0].as_ref().unwrap_err().code(),
tonic::Code::ResourceExhausted,
);
assert_eq!(
res[0].as_ref().unwrap_err().message(),
"Oversized frame in read response: frame_size=33, size_limit=1",
);
}
}
|
//https://leetcode.com/problems/maximum-69-number/submissions/
impl Solution {
pub fn maximum69_number (mut num: i32) -> i32 {
let mut max_69 = 0;
let mut last_change_dif = 0;
let mut ten_power = 1;
while num != 0 {
let current_digit = num % 10;
match current_digit {
9 => max_69 += current_digit * ten_power,
6 => {
max_69 += 9 * ten_power - last_change_dif;
last_change_dif = 3 * ten_power;
},
_ => ()
}
num /= 10;
ten_power *= 10;
}
max_69
}
} |
pub use embedded_hal::digital::v2::*;
pub use embedded_hal::prelude::*;
pub use crate::hal::adc::OneShot as _hal_adc_OneShot;
pub use crate::hal::watchdog::Watchdog as _hal_watchdog_Watchdog;
pub use crate::hal::watchdog::WatchdogEnable as _hal_watchdog_WatchdogEnable;
#[cfg(feature = "stm32l0x1")]
pub use crate::adc::AdcExt as _stm32l0xx_hal_analog_AdcExt;
pub use crate::delay::DelayExt as _stm32l0xx_hal_delay_DelayExt;
pub use crate::exti::ExtiExt as _stm32l0xx_hal_exti_ExtiExt;
pub use crate::gpio::GpioExt as _stm32l0xx_hal_gpio_GpioExt;
pub use crate::i2c::I2cExt as _stm32l0xx_hal_i2c_I2cExt;
pub use crate::pwm::PwmExt as _stm32l0xx_hal_pwm_PwmExt;
pub use crate::rcc::RccExt as _stm32l0xx_hal_rcc_RccExt;
pub use crate::serial::Serial1Ext as _stm32l0xx_hal_serial_Serial1Ext;
pub use crate::serial::Serial2Ext as _stm32l0xx_hal_serial_Serial2Ext;
pub use crate::spi::SpiExt as _stm32l0xx_hal_spi_SpiExt;
pub use crate::time::U32Ext as _stm32l0xx_hal_time_U32Ext;
pub use crate::timer::TimerExt as _stm32l0xx_hal_timer_TimerExt;
pub use crate::watchdog::IndependedWatchdogExt as _stm32l0xx_hal_watchdog_IndependedWatchdogExt;
pub use crate::watchdog::WindowWatchdogExt as _stm32l0xx_hal_watchdog_WindowWatchdogExt;
|
mod event;
mod mice;
pub use self::event::*;
pub use self::mice::*;
|
fn main() {
let s = "stressed";
let res = rev(s);
println!("{}", res);
}
fn rev(s: &str) -> String {
s.chars().rev().collect()
}
|
use crate::card::{Effect, EffectPair, Target};
use rand::rngs::SmallRng;
use rand::seq::SliceRandom;
use rand::FromEntropy;
use std::mem;
pub trait Actor: std::fmt::Debug {
fn set_intent(&mut self);
fn take_damage(&mut self, raw_damage: i32);
fn compute_damage(&self, raw_damage: i32) -> i32 {
raw_damage
}
fn add_block(&mut self, block: i32);
fn add_strength(&mut self, strength: i32);
fn add_weak(&mut self, weak: i32);
fn scale_attack(&self, base: i32) -> i32;
}
#[derive(Clone, Copy, Debug)]
pub struct Player {
pub health: i32,
pub block: i32,
pub energy: i32,
}
impl Actor for Player {
fn take_damage(&mut self, damage: i32) {
if self.block > 0 {
let mitigated = damage - self.block;
self.block -= damage as i32;
if mitigated > 0 {
self.health -= damage;
}
} else {
self.health -= damage;
}
}
fn set_intent(&mut self) {
unimplemented!()
}
fn add_block(&mut self, block: i32) {
self.block += block;
}
fn add_strength(&mut self, strength: i32) {
unimplemented!()
}
fn add_weak(&mut self, weak: i32) {
unimplemented!()
}
fn scale_attack(&self, base: i32) -> i32 {
base // Todo scale
}
}
#[derive(Debug, Clone)]
pub struct JawWorm {
pub health: i32,
pub block: i32,
pub strength: i32,
pub weak: i32,
pub intent: usize,
pub last_actions: Vec<usize>,
pub queue: Vec<EffectPair>,
}
impl Actor for JawWorm {
fn set_intent(&mut self) {
let mut rng = SmallRng::from_entropy();
let count = self.last_actions.len();
let choices = [0, 1, 2];
let mut probs = [45, 30, 25];
if count >= 2 {
if self.last_actions[count - 1] == 2 && self.last_actions[count - 2] == 2 {
//No bellow
probs[2] -= 25;
} else if self.last_actions[count - 1] == 0 && self.last_actions[count - 2] == 0 {
probs[0] -= 45;
} else if count >= 3
&& self.last_actions[count - 1] == 1
&& self.last_actions[count - 2] == 1
&& self.last_actions[count - 3] == 1
{
probs[1] -= 30;
}
}
let choice = choices
.choose_weighted(&mut rng, |choice| probs[*choice])
.unwrap();
match *choice {
0 => {
self.queue.push(pair![Attack, Single, 12]);
}
1 => {
self.queue.push(pair![Attack, Single, 7]);
self.queue.push(pair![Block, Player, 5]);
}
2 => {
self.queue.push(pair![Strength, Player, 5]);
self.queue.push(pair![Block, Player, 9]);
}
_ => {}
}
}
fn take_damage(&mut self, damage: i32) {
if self.block > 0 {
let mitigated = damage - self.block;
self.block -= damage;
if mitigated > 0 {
self.health -= damage;
}
} else {
self.health -= damage;
}
}
fn add_block(&mut self, block: i32) {
self.block += block;
}
fn add_strength(&mut self, strength: i32) {
self.strength += strength;
}
fn add_weak(&mut self, weak: i32) {
self.weak += weak;
}
fn scale_attack(&self, base: i32) -> i32 {
let mut scaled = base + self.strength;
if self.weak > 0 {
scaled -= scaled / 4 + (scaled % 4 != 0) as i32; // Fast int round up
}
scaled
}
}
impl JawWorm {
pub fn act(&mut self) -> Vec<EffectPair> {
let queue = mem::replace(&mut self.queue, Vec::new());
queue
}
}
|
use crate::protocol::Command::Xbox;
use crate::protocol::{AlphaKeys, BackKeys, Command, DirectionKeys, MetaKeys, Stick};
pub(super) fn parse_packet(data: &[u8]) -> Option<Command> {
// XBOX key packet
if data.len() == 6 && data[0] == 0x07 {
return Some(Xbox(data[4] != 0));
}
// Not a valid key packet
if data.len() != 18 {
println!("Refused to parse packet with len: {}", data.len());
return None;
}
match data[0] {
0x20 => Some(parse_button_data(data)),
value => {
println!("Unknown packet type: {}", value);
None
}
}
}
pub(super) fn parse_button_data(data: &[u8]) -> Command {
Command::Keys {
meta: MetaKeys {
select: data[4] & 0b0000_0100 != 0,
back: data[4] & 0b0000_1000 != 0,
},
alpha: AlphaKeys {
a: data[4] & 0b0001_0000 != 0,
b: data[4] & 0b010_0000 != 0,
x: data[4] & 0b0100_0000 != 0,
y: data[4] & 0b1000_0000 != 0,
},
direction: DirectionKeys {
up: data[5] & 0b0000_0001 != 0,
down: data[5] & 0b0000_0010 != 0,
left: data[5] & 0b0000_0100 != 0,
right: data[5] & 0b0000_1000 != 0,
},
back: BackKeys {
lb: data[5] & 0b0001_0000 != 0,
rb: data[5] & 0b0010_0000 != 0,
lt: ((data[7] as u16) << 8) | data[6] as u16,
rt: ((data[9] as u16) << 8) | data[8] as u16,
},
left_stick: Stick {
x: ((data[11] as i16) << 8) | data[10] as i16,
y: ((data[13] as i16) << 8) | data[12] as i16,
clicked: data[5] & 0b0100_0000 != 0,
},
right_stick: Stick {
x: ((data[15] as i16) << 8) | data[14] as i16,
y: ((data[17] as i16) << 8) | data[16] as i16,
clicked: data[5] & 0b1000_0000 != 0,
},
}
}
|
extern crate rayon;
extern crate rand;
extern crate statrs;
extern crate petgraph;
extern crate vec_graph;
extern crate capngraph;
extern crate ris;
extern crate bit_set;
extern crate docopt;
#[macro_use]
extern crate slog;
extern crate slog_stream;
extern crate slog_term;
extern crate slog_json;
extern crate serde;
extern crate serde_json;
extern crate bincode;
#[macro_use]
extern crate serde_derive;
extern crate rand_mersenne_twister;
#[macro_use]
extern crate nom;
use std::iter::FromIterator;
use std::collections::BTreeSet;
use std::fs::File;
use std::io::Read;
use petgraph::visit::NodeCount;
use vec_graph::{Graph, NodeIndex};
use rayon::prelude::*;
use slog::{Logger, DrainExt};
use serde_json::to_string as json_string;
use statrs::distribution::Categorical;
use rand::Rng;
use rand::distributions::IndependentSample;
use rand_mersenne_twister::{MTRng64, mersenne};
use bincode::{deserialize_from as bin_read_from, Infinite};
use std::cell::RefCell;
use std::path::Path;
use ris::*;
#[cfg_attr(rustfmt, rustfmt_skip)]
const USAGE: &'static str = "
Estimate the influence of a seed set via reverse influence sampling.
If <delta> is not given, 1/n is used as a default.
If --benefits are not given, then they are treated as uniformly 1.
Thus, ommitting both is equivalent to the normal unweighted IM problem.
Usage:
evaluate <graph> <model> <seeds> <epsilon> [<delta>] [options]
evaluate (-h | --help)
Options:
-h --help Show this screen.
--log <logfile> Log to given file.
--threads <threads> Number of threads to use.
--benefits <ben-file> Node benefits. Generated via the `build-data` binary.
";
#[derive(Serialize, Deserialize, Debug)]
struct Args {
arg_graph: String,
arg_model: Model,
arg_seeds: String,
arg_epsilon: f64,
arg_delta: Option<f64>,
flag_log: Option<String>,
flag_threads: Option<usize>,
flag_costs: Option<String>,
flag_benefits: Option<String>,
}
type BenVec = Vec<f64>;
type BenDist = Categorical;
#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
enum Model {
IC,
LT,
}
named!(seed<NodeIndex>, map!(map_res!(map_res!(ws!(nom::digit), std::str::from_utf8), std::str::FromStr::from_str), NodeIndex::new));
named!(seeds<BTreeSet<NodeIndex>>, terminated!(map!(many1!(seed), BTreeSet::from_iter), eof!()));
fn load_seeds<P: AsRef<Path>>(path: P) -> BTreeSet<NodeIndex> {
let input = File::open(path)
.expect("Unable to open seed file")
.bytes()
.collect::<Result<Vec<u8>, _>>()
.expect("Unable to read seed file");
let res = seeds(&input);
res.to_full_result().expect("Unable to parse seed file")
}
thread_local!(static RNG: RefCell<MTRng64> = RefCell::new(mersenne()));
/// Construct a reverse-reachable sample according to the BSA algorithm (see the SSA paper) under
/// either the IC or LT model.
///
/// If no benefits are given, this does uniform sampling.
///
/// WARN: copied from main.rs -- need to split into lib and unify
fn rr_sample<R: Rng>(rng: &mut R,
g: &Graph<(), f32>,
model: Model,
weights: &Option<BenDist>)
-> BTreeSet<NodeIndex> {
if let &Some(ref dist) = weights {
let v = dist.ind_sample(rng);
assert_eq!(v, v.trunc());
let v = NodeIndex::new(v as usize);
match model {
Model::IC => IC::new(rng, g, v),
Model::LT => LT::new(rng, g, v),
}
} else {
match model {
Model::IC => IC::new_uniform_with(rng, g),
Model::LT => LT::new_uniform_with(rng, g),
}
}
}
/// Constructs an (ε, δ)-approximation of the CTVM objective value.
fn evaluate(g: &Graph<(), f32>,
bens: Option<BenVec>,
model: Model,
seeds: &BTreeSet<NodeIndex>,
epsilon: f64,
delta: f64,
log: Logger)
-> f64 {
// for the sake of efficiency, we compute batches of size `step`
const STEP: usize = 10_000;
let mut num_cov: usize = 0;
let mut num_sets: usize = 0;
let n = g.node_count() as f64;
let dist = bens.as_ref().map(|w| Categorical::new(w).unwrap());
let gamma = bens.as_ref().map(|w| w.iter().sum::<f64>()).unwrap_or(n);
let dr = &dist;
let eps2 = epsilon / 16.0;
let delta2 = delta / 16.0;
let eps2p = eps2 / (1.0 - eps2);
let delta2p = delta2;
let lam2 = 1.0 +
(2.0 + 2.0 / 3.0 * eps2p) * (1.0 + eps2p) * (1.0 / delta2p).ln() * eps2p.powi(-2);
let lam2 = lam2.ceil() as usize;
while num_cov < lam2 {
// info!(log, "boosting coverage"; "cov" => num_cov, "λ₂" => lam2);
num_cov += (0..STEP)
.into_par_iter()
.map(move |_| RNG.with(|r| rr_sample(&mut *r.borrow_mut(), g, model, dr)))
.filter(|rr| rr.iter().any(|seed| seeds.contains(seed)))
.count();
num_sets += STEP;
}
info!(log, "verification complete"; "Λ₂" => lam2, "covered" => num_cov, "samples generated" => num_sets);
gamma * (num_cov as f64 / num_sets as f64)
}
fn main() {
let args: Args = docopt::Docopt::new(USAGE)
.and_then(|d| d.deserialize())
.unwrap_or_else(|e| e.exit());
if let Some(threads) = args.flag_threads {
rayon::initialize(rayon::Configuration::new().num_threads(threads)).unwrap();
}
let log =
match args.flag_log {
Some(ref filename) => slog::Logger::root(slog::Duplicate::new(slog_term::streamer().color().compact().build(),
slog_stream::stream(File::create(filename).unwrap(), slog_json::default())).fuse(), o!("version" => env!("CARGO_PKG_VERSION"))),
None => {
slog::Logger::root(slog_term::streamer().color().compact().build().fuse(),
o!("version" => env!("CARGO_PKG_VERSION")))
}
};
info!(log, "parameters"; "args" => json_string(&args).unwrap());
info!(log, "loading graph"; "path" => args.arg_graph);
let g = Graph::oriented_from_edges(capngraph::load_edges(args.arg_graph.as_str()).unwrap(),
petgraph::Incoming);
info!(log, "loaded graph");
let delta = args.arg_delta.unwrap_or(1.0 / g.node_count() as f64);
let bens: Option<BenVec> = args.flag_benefits
.as_ref()
.map(|path| bin_read_from(&mut File::open(path).unwrap(), Infinite).unwrap());
if let Some(ref b) = bens {
assert_eq!(b.len(), g.node_count());
info!(log, "loaded benefits");
}
let seeds = load_seeds(&args.arg_seeds);
info!(log, "loaded seeds");
let influence = evaluate(&g,
bens,
args.arg_model,
&seeds,
args.arg_epsilon,
delta,
log.new(o!("section" => "verify")));
info!(log, "estimated influence"; "seeds" => json_string(&seeds.into_iter().map(|node| node.index()).collect::<Vec<_>>()).unwrap(), "influence" => influence);
}
|
extern crate image;
use image::GenericImageView;
use std::fs;
fn save_jpg_clean(path: &str) {
println!("salvando {} em editadas", path);
let img = image::open(path).unwrap();
println!("dimensions: {:?}, color: {:?}\n",
img.dimensions(),
img.color()
);
img.save(format!("editadas/{}", path)).unwrap();
}
fn main() {
let _ = fs::create_dir("editadas");
let paths = fs::read_dir("./").unwrap();
for path in paths {
let file = path.unwrap().path();
let name = file.display();
let extension = file.extension();
match extension {
None => {},
Some(ext) => {
if ext == "jpg" {
save_jpg_clean(&name.to_string());
}
}
}
}
}
|
#![allow(non_snake_case)]
use core::convert::TryInto;
use test_winrt_signatures::*;
use windows::core::*;
use Component::Signatures::*;
use Component::Structs::*;
use Windows::Foundation::PropertyValue;
#[implement(Component::Signatures::ITestNonBlittable)]
struct RustTest();
impl RustTest {
fn SignatureNonBlittable(&self, a: &NonBlittable, b: &NonBlittable, c: &mut NonBlittable) -> Result<NonBlittable> {
assert!(a == b);
*c = a.clone();
Ok(a.clone())
}
fn ArraySignatureNonBlittable(&self, a: &[NonBlittable], b: &mut [NonBlittable], c: &mut Array<NonBlittable>) -> Result<Array<NonBlittable>> {
assert!(a.len() == b.len());
assert!(c.is_empty());
b.clone_from_slice(a);
*c = Array::from_slice(a);
Ok(Array::from_slice(a))
}
fn CallSignatureNonBlittable(&self, handler: &Option<SignatureNonBlittable>) -> Result<()> {
let a = NonBlittable {
String: "string".into(),
// TODO: better boxing support is needed
RefInt64: Some(PropertyValue::CreateInt64(123)?.cast()?),
};
let mut b = NonBlittable::default();
// TODO: this seems rather verbose...
let c = handler.as_ref().unwrap().Invoke(&a, &a, &mut b)?;
assert!(&a == &b);
assert!(&a == &c);
Ok(())
}
fn CallArraySignatureNonBlittable(&self, handler: &Option<ArraySignatureNonBlittable>) -> Result<()> {
let a = [
NonBlittable {
String: "first".into(),
// TODO: better boxing support is needed
RefInt64: Some(PropertyValue::CreateInt64(1)?.cast()?),
},
NonBlittable {
String: "second".into(),
// TODO: better boxing support is needed
RefInt64: Some(PropertyValue::CreateInt64(2)?.cast()?),
},
NonBlittable {
String: "third".into(),
// TODO: better boxing support is needed
RefInt64: Some(PropertyValue::CreateInt64(3)?.cast()?),
},
];
let mut b = [NonBlittable::default(), NonBlittable::default(), NonBlittable::default()];
let mut c = Array::new();
let d = handler.as_ref().unwrap().Invoke(&a, &mut b, &mut c)?;
assert!(a == b);
// TODO: should `a == c` be sufficient? Does that work for Vec?
assert!(a == c[..]);
assert!(a == d[..]);
Ok(())
}
}
fn test_interface(test: &ITestNonBlittable) -> Result<()> {
let a = NonBlittable {
String: "string".into(),
// TODO: better boxing support is needed
RefInt64: Some(PropertyValue::CreateInt64(123)?.cast()?),
};
let mut b = NonBlittable::default();
let c = test.SignatureNonBlittable(&a, &a, &mut b)?;
assert!(&a == &b);
assert!(&a == &c);
test.CallSignatureNonBlittable(SignatureNonBlittable::new(|a, b, c| {
assert!(a == b);
*c = a.clone();
Ok(a.clone())
}))?;
let a = [
NonBlittable {
String: "first".into(),
// TODO: better boxing support is needed
RefInt64: Some(PropertyValue::CreateInt64(1)?.cast()?),
},
NonBlittable {
String: "second".into(),
// TODO: better boxing support is needed
RefInt64: Some(PropertyValue::CreateInt64(2)?.cast()?),
},
NonBlittable {
String: "third".into(),
// TODO: better boxing support is needed
RefInt64: Some(PropertyValue::CreateInt64(3)?.cast()?),
},
];
let mut b = [NonBlittable::default(), NonBlittable::default(), NonBlittable::default()];
let mut c = Array::new();
let d = test.ArraySignatureNonBlittable(&a, &mut b, &mut c)?;
assert!(a == b);
assert!(a == c[..]);
assert!(a == d[..]);
test.CallArraySignatureNonBlittable(ArraySignatureNonBlittable::new(|a, b, c| {
assert!(a.len() == b.len());
assert!(c.is_empty());
b.clone_from_slice(a);
*c = Array::from_slice(a);
Ok(Array::from_slice(a))
}))?;
Ok(())
}
#[test]
fn test() -> Result<()> {
test_interface(&Test::new()?.try_into()?)?;
test_interface(&RustTest().into())?;
Ok(())
}
|
#![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
pub const APPMODEL_ERROR_DYNAMIC_PROPERTY_INVALID: i32 = 15705i32;
pub const APPMODEL_ERROR_DYNAMIC_PROPERTY_READ_FAILED: i32 = 15704i32;
pub const APPMODEL_ERROR_NO_APPLICATION: i32 = 15703i32;
pub const APPMODEL_ERROR_NO_MUTABLE_DIRECTORY: i32 = 15707i32;
pub const APPMODEL_ERROR_NO_PACKAGE: i32 = 15700i32;
pub const APPMODEL_ERROR_PACKAGE_IDENTITY_CORRUPT: i32 = 15702i32;
pub const APPMODEL_ERROR_PACKAGE_NOT_AVAILABLE: i32 = 15706i32;
pub const APPMODEL_ERROR_PACKAGE_RUNTIME_CORRUPT: i32 = 15701i32;
pub const APPX_E_BLOCK_HASH_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958841i32 as _);
pub const APPX_E_CORRUPT_CONTENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958842i32 as _);
pub const APPX_E_DELTA_APPENDED_PACKAGE_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958832i32 as _);
pub const APPX_E_DELTA_BASELINE_VERSION_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958835i32 as _);
pub const APPX_E_DELTA_PACKAGE_MISSING_FILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958834i32 as _);
pub const APPX_E_FILE_COMPRESSION_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958828i32 as _);
pub const APPX_E_INTERLEAVING_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958847i32 as _);
pub const APPX_E_INVALID_APPINSTALLER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958836i32 as _);
pub const APPX_E_INVALID_BLOCKMAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958843i32 as _);
pub const APPX_E_INVALID_CONTENTGROUPMAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958837i32 as _);
pub const APPX_E_INVALID_DELTA_PACKAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958833i32 as _);
pub const APPX_E_INVALID_ENCRYPTION_EXCLUSION_FILE_LIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958826i32 as _);
pub const APPX_E_INVALID_KEY_INFO: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958838i32 as _);
pub const APPX_E_INVALID_MANIFEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958844i32 as _);
pub const APPX_E_INVALID_PACKAGESIGNCONFIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958830i32 as _);
pub const APPX_E_INVALID_PACKAGE_FOLDER_ACLS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958825i32 as _);
pub const APPX_E_INVALID_PACKAGING_LAYOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958831i32 as _);
pub const APPX_E_INVALID_PAYLOAD_PACKAGE_EXTENSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958827i32 as _);
pub const APPX_E_INVALID_PUBLISHER_BRIDGING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958824i32 as _);
pub const APPX_E_INVALID_SIP_CLIENT_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958839i32 as _);
pub const APPX_E_MISSING_REQUIRED_FILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958845i32 as _);
pub const APPX_E_PACKAGING_INTERNAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958848i32 as _);
pub const APPX_E_RELATIONSHIPS_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958846i32 as _);
pub const APPX_E_REQUESTED_RANGE_TOO_LARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958840i32 as _);
pub const APPX_E_RESOURCESPRI_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958829i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct APP_LOCAL_DEVICE_ID {
pub value: [u8; 32],
}
impl APP_LOCAL_DEVICE_ID {}
impl ::core::default::Default for APP_LOCAL_DEVICE_ID {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for APP_LOCAL_DEVICE_ID {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("APP_LOCAL_DEVICE_ID").field("value", &self.value).finish()
}
}
impl ::core::cmp::PartialEq for APP_LOCAL_DEVICE_ID {
fn eq(&self, other: &Self) -> bool {
self.value == other.value
}
}
impl ::core::cmp::Eq for APP_LOCAL_DEVICE_ID {}
unsafe impl ::windows::core::Abi for APP_LOCAL_DEVICE_ID {
type Abi = Self;
}
pub const APP_LOCAL_DEVICE_ID_SIZE: u32 = 32u32;
#[repr(transparent)]
#[derive(:: core :: default :: Default, :: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: fmt :: Debug)]
pub struct BOOL(pub i32);
unsafe impl ::windows::core::Abi for BOOL {
type Abi = Self;
}
impl BOOL {
#[inline]
pub fn as_bool(self) -> bool {
!(self.0 == 0)
}
#[inline]
pub fn ok(self) -> ::windows::core::Result<()> {
if self.as_bool() {
Ok(())
} else {
Err(::windows::core::Error::from_win32())
}
}
#[inline]
#[track_caller]
pub fn unwrap(self) {
self.ok().unwrap();
}
#[inline]
#[track_caller]
pub fn expect(self, msg: &str) {
self.ok().expect(msg);
}
}
impl ::core::convert::From<BOOL> for bool {
fn from(value: BOOL) -> Self {
value.as_bool()
}
}
impl ::core::convert::From<&BOOL> for bool {
fn from(value: &BOOL) -> Self {
value.as_bool()
}
}
impl ::core::convert::From<bool> for BOOL {
fn from(value: bool) -> Self {
if value {
BOOL(1)
} else {
BOOL(0)
}
}
}
impl ::core::convert::From<&bool> for BOOL {
fn from(value: &bool) -> Self {
(*value).into()
}
}
impl ::core::cmp::PartialEq<bool> for BOOL {
fn eq(&self, other: &bool) -> bool {
self.as_bool() == *other
}
}
impl ::core::cmp::PartialEq<BOOL> for bool {
fn eq(&self, other: &BOOL) -> bool {
*self == other.as_bool()
}
}
impl ::core::ops::Not for BOOL {
type Output = Self;
fn not(self) -> Self::Output {
if self.as_bool() {
BOOL(0)
} else {
BOOL(1)
}
}
}
impl<'a> ::windows::core::IntoParam<'a, BOOL> for bool {
fn into_param(self) -> ::windows::core::Param<'a, BOOL> {
::windows::core::Param::Owned(self.into())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct BOOLEAN(pub u8);
impl ::core::default::Default for BOOLEAN {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
unsafe impl ::windows::core::Handle for BOOLEAN {}
unsafe impl ::windows::core::Abi for BOOLEAN {
type Abi = Self;
}
#[repr(transparent)]
#[derive(:: core :: cmp :: Eq)]
pub struct BSTR(pub *mut u16);
impl BSTR {
pub fn new() -> Self {
Self(core::ptr::null_mut())
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn len(&self) -> usize {
if self.0.is_null() {
0
} else {
unsafe { SysStringLen(self) as usize }
}
}
pub fn from_wide(value: &[u16]) -> Self {
if value.len() == 0 {
return Self(::core::ptr::null_mut());
}
unsafe { SysAllocStringLen(PWSTR(value.as_ptr() as *mut _), value.len() as u32) }
}
pub fn as_wide(&self) -> &[u16] {
if self.0.is_null() {
return &[];
}
unsafe { ::core::slice::from_raw_parts(self.0 as *const u16, self.len()) }
}
}
impl ::core::clone::Clone for BSTR {
fn clone(&self) -> Self {
Self::from_wide(self.as_wide())
}
}
impl ::core::convert::From<&str> for BSTR {
fn from(value: &str) -> Self {
let value: ::windows::core::alloc::vec::Vec<u16> = value.encode_utf16().collect();
Self::from_wide(&value)
}
}
impl ::core::convert::From<::windows::core::alloc::string::String> for BSTR {
fn from(value: ::windows::core::alloc::string::String) -> Self {
value.as_str().into()
}
}
impl ::core::convert::From<&::windows::core::alloc::string::String> for BSTR {
fn from(value: &::windows::core::alloc::string::String) -> Self {
value.as_str().into()
}
}
impl<'a> ::core::convert::TryFrom<&'a BSTR> for ::windows::core::alloc::string::String {
type Error = ::windows::core::alloc::string::FromUtf16Error;
fn try_from(value: &BSTR) -> ::core::result::Result<Self, Self::Error> {
::windows::core::alloc::string::String::from_utf16(value.as_wide())
}
}
impl ::core::convert::TryFrom<BSTR> for ::windows::core::alloc::string::String {
type Error = ::windows::core::alloc::string::FromUtf16Error;
fn try_from(value: BSTR) -> ::core::result::Result<Self, Self::Error> {
::windows::core::alloc::string::String::try_from(&value)
}
}
impl ::core::default::Default for BSTR {
fn default() -> Self {
Self(::core::ptr::null_mut())
}
}
impl ::core::fmt::Display for BSTR {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
use core::fmt::Write;
for c in ::core::char::decode_utf16(self.as_wide().iter().cloned()) {
f.write_char(c.map_err(|_| ::core::fmt::Error)?)?
}
Ok(())
}
}
impl ::core::fmt::Debug for BSTR {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
::core::write!(f, "{}", self)
}
}
impl ::core::cmp::PartialEq for BSTR {
fn eq(&self, other: &Self) -> bool {
self.as_wide() == other.as_wide()
}
}
impl ::core::cmp::PartialEq<::windows::core::alloc::string::String> for BSTR {
fn eq(&self, other: &::windows::core::alloc::string::String) -> bool {
self == other.as_str()
}
}
impl ::core::cmp::PartialEq<str> for BSTR {
fn eq(&self, other: &str) -> bool {
self == other
}
}
impl ::core::cmp::PartialEq<&str> for BSTR {
fn eq(&self, other: &&str) -> bool {
self.as_wide().iter().copied().eq(other.encode_utf16())
}
}
impl ::core::cmp::PartialEq<BSTR> for &str {
fn eq(&self, other: &BSTR) -> bool {
other == self
}
}
impl ::core::ops::Drop for BSTR {
fn drop(&mut self) {
if !self.0.is_null() {
unsafe { SysFreeString(self as &Self) }
}
}
}
unsafe impl ::windows::core::Abi for BSTR {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
pub type BSTR_abi = *mut u16;
#[cfg(feature = "alloc")]
impl<'a> ::windows::core::IntoParam<'a, BSTR> for &str {
fn into_param(self) -> ::windows::core::Param<'a, BSTR> {
::windows::core::Param::Owned(self.into())
}
}
#[cfg(feature = "alloc")]
impl<'a> ::windows::core::IntoParam<'a, BSTR> for ::windows::core::alloc::string::String {
fn into_param(self) -> ::windows::core::Param<'a, BSTR> {
::windows::core::Param::Owned(self.into())
}
}
pub const BT_E_SPURIOUS_ACTIVATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146958592i32 as _);
pub const CACHE_E_FIRST: i32 = -2147221136i32;
pub const CACHE_E_LAST: i32 = -2147221121i32;
pub const CACHE_E_NOCACHE_UPDATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221136i32 as _);
pub const CACHE_S_FIRST: i32 = 262512i32;
pub const CACHE_S_FORMATETC_NOTSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(262512i32 as _);
pub const CACHE_S_LAST: i32 = 262527i32;
pub const CACHE_S_SAMECACHE: ::windows::core::HRESULT = ::windows::core::HRESULT(262513i32 as _);
pub const CACHE_S_SOMECACHES_NOTUPDATED: ::windows::core::HRESULT = ::windows::core::HRESULT(262514i32 as _);
pub const CAT_E_CATIDNOEXIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221152i32 as _);
pub const CAT_E_FIRST: i32 = -2147221152i32;
pub const CAT_E_LAST: i32 = -2147221151i32;
pub const CAT_E_NODESCRIPTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221151i32 as _);
pub const CERTSRV_E_ADMIN_DENIED_REQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877420i32 as _);
pub const CERTSRV_E_ALIGNMENT_FAULT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877424i32 as _);
pub const CERTSRV_E_ARCHIVED_KEY_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875388i32 as _);
pub const CERTSRV_E_ARCHIVED_KEY_UNEXPECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875376i32 as _);
pub const CERTSRV_E_BAD_RENEWAL_CERT_ATTRIBUTE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877426i32 as _);
pub const CERTSRV_E_BAD_RENEWAL_SUBJECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875386i32 as _);
pub const CERTSRV_E_BAD_REQUESTSTATUS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877437i32 as _);
pub const CERTSRV_E_BAD_REQUESTSUBJECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877439i32 as _);
pub const CERTSRV_E_BAD_REQUEST_KEY_ARCHIVAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877428i32 as _);
pub const CERTSRV_E_BAD_TEMPLATE_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875385i32 as _);
pub const CERTSRV_E_CERT_TYPE_OVERLAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875372i32 as _);
pub const CERTSRV_E_CORRUPT_KEY_ATTESTATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875365i32 as _);
pub const CERTSRV_E_DOWNLEVEL_DC_SSL_OR_UPGRADE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877421i32 as _);
pub const CERTSRV_E_ENCODING_LENGTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877433i32 as _);
pub const CERTSRV_E_ENCRYPTION_CERT_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877416i32 as _);
pub const CERTSRV_E_ENROLL_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877423i32 as _);
pub const CERTSRV_E_EXPIRED_CHALLENGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875364i32 as _);
pub const CERTSRV_E_INVALID_ATTESTATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875367i32 as _);
pub const CERTSRV_E_INVALID_CA_CERTIFICATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877435i32 as _);
pub const CERTSRV_E_INVALID_EK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875369i32 as _);
pub const CERTSRV_E_INVALID_IDBINDING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875368i32 as _);
pub const CERTSRV_E_INVALID_REQUESTID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875362i32 as _);
pub const CERTSRV_E_INVALID_RESPONSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875363i32 as _);
pub const CERTSRV_E_ISSUANCE_POLICY_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875380i32 as _);
pub const CERTSRV_E_KEY_ARCHIVAL_NOT_CONFIGURED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877430i32 as _);
pub const CERTSRV_E_KEY_ATTESTATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875366i32 as _);
pub const CERTSRV_E_KEY_ATTESTATION_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877417i32 as _);
pub const CERTSRV_E_KEY_LENGTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875375i32 as _);
pub const CERTSRV_E_NO_CAADMIN_DEFINED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877427i32 as _);
pub const CERTSRV_E_NO_CERT_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875391i32 as _);
pub const CERTSRV_E_NO_DB_SESSIONS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877425i32 as _);
pub const CERTSRV_E_NO_POLICY_SERVER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877419i32 as _);
pub const CERTSRV_E_NO_REQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877438i32 as _);
pub const CERTSRV_E_NO_VALID_KRA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877429i32 as _);
pub const CERTSRV_E_PENDING_CLIENT_RESPONSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875360i32 as _);
pub const CERTSRV_E_PROPERTY_EMPTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877436i32 as _);
pub const CERTSRV_E_RENEWAL_BAD_PUBLIC_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875370i32 as _);
pub const CERTSRV_E_REQUEST_PRECERTIFICATE_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875361i32 as _);
pub const CERTSRV_E_RESTRICTEDOFFICER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877431i32 as _);
pub const CERTSRV_E_ROLECONFLICT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877432i32 as _);
pub const CERTSRV_E_SERVER_SUSPENDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877434i32 as _);
pub const CERTSRV_E_SIGNATURE_COUNT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875382i32 as _);
pub const CERTSRV_E_SIGNATURE_POLICY_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875383i32 as _);
pub const CERTSRV_E_SIGNATURE_REJECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875381i32 as _);
pub const CERTSRV_E_SMIME_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875387i32 as _);
pub const CERTSRV_E_SUBJECT_ALT_NAME_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875389i32 as _);
pub const CERTSRV_E_SUBJECT_DIRECTORY_GUID_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875378i32 as _);
pub const CERTSRV_E_SUBJECT_DNS_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875377i32 as _);
pub const CERTSRV_E_SUBJECT_EMAIL_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875374i32 as _);
pub const CERTSRV_E_SUBJECT_UPN_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875379i32 as _);
pub const CERTSRV_E_TEMPLATE_CONFLICT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875390i32 as _);
pub const CERTSRV_E_TEMPLATE_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877422i32 as _);
pub const CERTSRV_E_TEMPLATE_POLICY_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875384i32 as _);
pub const CERTSRV_E_TOO_MANY_SIGNATURES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875371i32 as _);
pub const CERTSRV_E_UNKNOWN_CERT_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875373i32 as _);
pub const CERTSRV_E_UNSUPPORTED_CERT_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146875392i32 as _);
pub const CERTSRV_E_WEAK_SIGNATURE_OR_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146877418i32 as _);
pub const CERT_E_CHAINING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762486i32 as _);
pub const CERT_E_CN_NO_MATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762481i32 as _);
pub const CERT_E_CRITICAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762491i32 as _);
pub const CERT_E_EXPIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762495i32 as _);
pub const CERT_E_INVALID_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762476i32 as _);
pub const CERT_E_INVALID_POLICY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762477i32 as _);
pub const CERT_E_ISSUERCHAINING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762489i32 as _);
pub const CERT_E_MALFORMED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762488i32 as _);
pub const CERT_E_PATHLENCONST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762492i32 as _);
pub const CERT_E_PURPOSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762490i32 as _);
pub const CERT_E_REVOCATION_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762482i32 as _);
pub const CERT_E_REVOKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762484i32 as _);
pub const CERT_E_ROLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762493i32 as _);
pub const CERT_E_UNTRUSTEDCA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762478i32 as _);
pub const CERT_E_UNTRUSTEDROOT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762487i32 as _);
pub const CERT_E_UNTRUSTEDTESTROOT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762483i32 as _);
pub const CERT_E_VALIDITYPERIODNESTING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762494i32 as _);
pub const CERT_E_WRONG_USAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762480i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct CHAR(pub u8);
impl ::core::default::Default for CHAR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
unsafe impl ::windows::core::Handle for CHAR {}
unsafe impl ::windows::core::Abi for CHAR {
type Abi = Self;
}
pub const CI_CORRUPT_CATALOG: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473535i32 as _);
pub const CI_CORRUPT_DATABASE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473536i32 as _);
pub const CI_CORRUPT_FILTER_BUFFER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473529i32 as _);
pub const CI_E_ALREADY_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215350i32 as _);
pub const CI_E_BUFFERTOOSMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215348i32 as _);
pub const CI_E_CARDINALITY_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215321i32 as _);
pub const CI_E_CLIENT_FILTER_ABORT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473500i32 as _);
pub const CI_E_CONFIG_DISK_FULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215320i32 as _);
pub const CI_E_DISK_FULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215343i32 as _);
pub const CI_E_DISTRIBUTED_GROUPBY_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215319i32 as _);
pub const CI_E_DUPLICATE_NOTIFICATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215337i32 as _);
pub const CI_E_ENUMERATION_STARTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473502i32 as _);
pub const CI_E_FILTERING_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215344i32 as _);
pub const CI_E_INVALID_FLAGS_COMBINATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215335i32 as _);
pub const CI_E_INVALID_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215345i32 as _);
pub const CI_E_LOGON_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215332i32 as _);
pub const CI_E_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215339i32 as _);
pub const CI_E_NOT_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215349i32 as _);
pub const CI_E_NOT_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215328i32 as _);
pub const CI_E_NO_CATALOG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215331i32 as _);
pub const CI_E_OUTOFSEQ_INCREMENT_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215334i32 as _);
pub const CI_E_PROPERTY_NOT_CACHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215347i32 as _);
pub const CI_E_PROPERTY_TOOLARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473501i32 as _);
pub const CI_E_SHARING_VIOLATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215333i32 as _);
pub const CI_E_SHUTDOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215342i32 as _);
pub const CI_E_STRANGE_PAGEORSECTOR_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215330i32 as _);
pub const CI_E_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215329i32 as _);
pub const CI_E_UPDATES_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215336i32 as _);
pub const CI_E_USE_DEFAULT_PID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215338i32 as _);
pub const CI_E_WORKID_NOTVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215341i32 as _);
pub const CI_INCORRECT_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473503i32 as _);
pub const CI_INVALID_INDEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473528i32 as _);
pub const CI_INVALID_PARTITION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473534i32 as _);
pub const CI_INVALID_PRIORITY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473533i32 as _);
pub const CI_NO_CATALOG: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473530i32 as _);
pub const CI_NO_STARTING_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473532i32 as _);
pub const CI_OUT_OF_INDEX_IDS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473531i32 as _);
pub const CI_PROPSTORE_INCONSISTENCY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473527i32 as _);
pub const CI_S_CAT_STOPPED: ::windows::core::HRESULT = ::windows::core::HRESULT(268326i32 as _);
pub const CI_S_END_OF_ENUMERATION: ::windows::core::HRESULT = ::windows::core::HRESULT(268308i32 as _);
pub const CI_S_NO_DOCSTORE: ::windows::core::HRESULT = ::windows::core::HRESULT(268325i32 as _);
pub const CI_S_WORKID_DELETED: ::windows::core::HRESULT = ::windows::core::HRESULT(268302i32 as _);
pub const CLASSFACTORY_E_FIRST: i32 = -2147221232i32;
pub const CLASSFACTORY_E_LAST: i32 = -2147221217i32;
pub const CLASSFACTORY_S_FIRST: i32 = 262416i32;
pub const CLASSFACTORY_S_LAST: i32 = 262431i32;
pub const CLASS_E_CLASSNOTAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221231i32 as _);
pub const CLASS_E_NOAGGREGATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221232i32 as _);
pub const CLASS_E_NOTLICENSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221230i32 as _);
pub const CLIENTSITE_E_FIRST: i32 = -2147221104i32;
pub const CLIENTSITE_E_LAST: i32 = -2147221089i32;
pub const CLIENTSITE_S_FIRST: i32 = 262544i32;
pub const CLIENTSITE_S_LAST: i32 = 262559i32;
pub const CLIPBRD_E_BAD_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221037i32 as _);
pub const CLIPBRD_E_CANT_CLOSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221036i32 as _);
pub const CLIPBRD_E_CANT_EMPTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221039i32 as _);
pub const CLIPBRD_E_CANT_OPEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221040i32 as _);
pub const CLIPBRD_E_CANT_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221038i32 as _);
pub const CLIPBRD_E_FIRST: i32 = -2147221040i32;
pub const CLIPBRD_E_LAST: i32 = -2147221025i32;
pub const CLIPBRD_S_FIRST: i32 = 262608i32;
pub const CLIPBRD_S_LAST: i32 = 262623i32;
pub const COMADMIN_E_ALREADYINSTALLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368508i32 as _);
pub const COMADMIN_E_AMBIGUOUS_APPLICATION_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368420i32 as _);
pub const COMADMIN_E_AMBIGUOUS_PARTITION_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368419i32 as _);
pub const COMADMIN_E_APPDIRNOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368481i32 as _);
pub const COMADMIN_E_APPLICATIONEXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368501i32 as _);
pub const COMADMIN_E_APPLID_MATCHES_CLSID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368442i32 as _);
pub const COMADMIN_E_APP_FILE_READFAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368504i32 as _);
pub const COMADMIN_E_APP_FILE_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368503i32 as _);
pub const COMADMIN_E_APP_FILE_WRITEFAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368505i32 as _);
pub const COMADMIN_E_APP_NOT_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367478i32 as _);
pub const COMADMIN_E_AUTHENTICATIONLEVEL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368493i32 as _);
pub const COMADMIN_E_BADPATH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368502i32 as _);
pub const COMADMIN_E_BADREGISTRYLIBID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368482i32 as _);
pub const COMADMIN_E_BADREGISTRYPROGID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368494i32 as _);
pub const COMADMIN_E_BASEPARTITION_REQUIRED_IN_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367457i32 as _);
pub const COMADMIN_E_BASE_PARTITION_ONLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368432i32 as _);
pub const COMADMIN_E_CANNOT_ALIAS_EVENTCLASS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367456i32 as _);
pub const COMADMIN_E_CANTCOPYFILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368499i32 as _);
pub const COMADMIN_E_CANTMAKEINPROCSERVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367468i32 as _);
pub const COMADMIN_E_CANTRECYCLELIBRARYAPPS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367473i32 as _);
pub const COMADMIN_E_CANTRECYCLESERVICEAPPS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367471i32 as _);
pub const COMADMIN_E_CANT_SUBSCRIBE_TO_COMPONENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368435i32 as _);
pub const COMADMIN_E_CAN_NOT_EXPORT_APP_PROXY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368438i32 as _);
pub const COMADMIN_E_CAN_NOT_EXPORT_SYS_APP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368436i32 as _);
pub const COMADMIN_E_CAN_NOT_START_APP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368437i32 as _);
pub const COMADMIN_E_CAT_BITNESSMISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368382i32 as _);
pub const COMADMIN_E_CAT_DUPLICATE_PARTITION_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368425i32 as _);
pub const COMADMIN_E_CAT_IMPORTED_COMPONENTS_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368421i32 as _);
pub const COMADMIN_E_CAT_INVALID_PARTITION_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368424i32 as _);
pub const COMADMIN_E_CAT_PARTITION_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368423i32 as _);
pub const COMADMIN_E_CAT_PAUSE_RESUME_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368379i32 as _);
pub const COMADMIN_E_CAT_SERVERFAULT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368378i32 as _);
pub const COMADMIN_E_CAT_UNACCEPTABLEBITNESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368381i32 as _);
pub const COMADMIN_E_CAT_WRONGAPPBITNESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368380i32 as _);
pub const COMADMIN_E_CLSIDORIIDMISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368488i32 as _);
pub const COMADMIN_E_COMPFILE_BADTLB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368472i32 as _);
pub const COMADMIN_E_COMPFILE_CLASSNOTAVAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368473i32 as _);
pub const COMADMIN_E_COMPFILE_DOESNOTEXIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368476i32 as _);
pub const COMADMIN_E_COMPFILE_GETCLASSOBJ: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368474i32 as _);
pub const COMADMIN_E_COMPFILE_LOADDLLFAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368475i32 as _);
pub const COMADMIN_E_COMPFILE_NOREGISTRAR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368460i32 as _);
pub const COMADMIN_E_COMPFILE_NOTINSTALLABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368471i32 as _);
pub const COMADMIN_E_COMPONENTEXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368455i32 as _);
pub const COMADMIN_E_COMP_MOVE_BAD_DEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368466i32 as _);
pub const COMADMIN_E_COMP_MOVE_DEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367459i32 as _);
pub const COMADMIN_E_COMP_MOVE_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368467i32 as _);
pub const COMADMIN_E_COMP_MOVE_PRIVATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367458i32 as _);
pub const COMADMIN_E_COMP_MOVE_SOURCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367460i32 as _);
pub const COMADMIN_E_COREQCOMPINSTALLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368459i32 as _);
pub const COMADMIN_E_DEFAULT_PARTITION_NOT_IN_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367466i32 as _);
pub const COMADMIN_E_DLLLOADFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368483i32 as _);
pub const COMADMIN_E_DLLREGISTERSERVER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368486i32 as _);
pub const COMADMIN_E_EVENTCLASS_CANT_BE_SUBSCRIBER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368434i32 as _);
pub const COMADMIN_E_FILE_PARTITION_DUPLICATE_FILES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368422i32 as _);
pub const COMADMIN_E_INVALIDUSERIDS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368496i32 as _);
pub const COMADMIN_E_INVALID_PARTITION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367477i32 as _);
pub const COMADMIN_E_KEYMISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368509i32 as _);
pub const COMADMIN_E_LEGACYCOMPS_NOT_ALLOWED_IN_1_0_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367462i32 as _);
pub const COMADMIN_E_LEGACYCOMPS_NOT_ALLOWED_IN_NONBASE_PARTITIONS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367461i32 as _);
pub const COMADMIN_E_LIB_APP_PROXY_INCOMPATIBLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368433i32 as _);
pub const COMADMIN_E_MIG_SCHEMANOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368383i32 as _);
pub const COMADMIN_E_MIG_VERSIONNOTSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368384i32 as _);
pub const COMADMIN_E_NOREGISTRYCLSID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368495i32 as _);
pub const COMADMIN_E_NOSERVERSHARE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368485i32 as _);
pub const COMADMIN_E_NOTCHANGEABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368470i32 as _);
pub const COMADMIN_E_NOTDELETEABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368469i32 as _);
pub const COMADMIN_E_NOTINREGISTRY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368450i32 as _);
pub const COMADMIN_E_NOUSER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368497i32 as _);
pub const COMADMIN_E_OBJECTERRORS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368511i32 as _);
pub const COMADMIN_E_OBJECTEXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368456i32 as _);
pub const COMADMIN_E_OBJECTINVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368510i32 as _);
pub const COMADMIN_E_OBJECTNOTPOOLABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368449i32 as _);
pub const COMADMIN_E_OBJECT_DOES_NOT_EXIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367479i32 as _);
pub const COMADMIN_E_OBJECT_PARENT_MISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367480i32 as _);
pub const COMADMIN_E_PARTITIONS_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367452i32 as _);
pub const COMADMIN_E_PARTITION_ACCESSDENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367464i32 as _);
pub const COMADMIN_E_PARTITION_MSI_ONLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367463i32 as _);
pub const COMADMIN_E_PAUSEDPROCESSMAYNOTBERECYCLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367469i32 as _);
pub const COMADMIN_E_PRIVATE_ACCESSDENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367455i32 as _);
pub const COMADMIN_E_PROCESSALREADYRECYCLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367470i32 as _);
pub const COMADMIN_E_PROGIDINUSEBYCLSID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367467i32 as _);
pub const COMADMIN_E_PROPERTYSAVEFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368457i32 as _);
pub const COMADMIN_E_PROPERTY_OVERFLOW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368452i32 as _);
pub const COMADMIN_E_RECYCLEDPROCESSMAYNOTBEPAUSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367465i32 as _);
pub const COMADMIN_E_REGDB_ALREADYRUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368395i32 as _);
pub const COMADMIN_E_REGDB_NOTINITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368398i32 as _);
pub const COMADMIN_E_REGDB_NOTOPEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368397i32 as _);
pub const COMADMIN_E_REGDB_SYSTEMERR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368396i32 as _);
pub const COMADMIN_E_REGFILE_CORRUPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368453i32 as _);
pub const COMADMIN_E_REGISTERTLB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368464i32 as _);
pub const COMADMIN_E_REGISTRARFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368477i32 as _);
pub const COMADMIN_E_REGISTRY_ACCESSDENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367453i32 as _);
pub const COMADMIN_E_REMOTEINTERFACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368487i32 as _);
pub const COMADMIN_E_REQUIRES_DIFFERENT_PLATFORM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368439i32 as _);
pub const COMADMIN_E_ROLEEXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368500i32 as _);
pub const COMADMIN_E_ROLE_DOES_NOT_EXIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368441i32 as _);
pub const COMADMIN_E_SAFERINVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367454i32 as _);
pub const COMADMIN_E_SERVICENOTINSTALLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368458i32 as _);
pub const COMADMIN_E_SESSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368468i32 as _);
pub const COMADMIN_E_START_APP_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368431i32 as _);
pub const COMADMIN_E_START_APP_NEEDS_COMPONENTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368440i32 as _);
pub const COMADMIN_E_SVCAPP_NOT_POOLABLE_OR_RECYCLABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367475i32 as _);
pub const COMADMIN_E_SYSTEMAPP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368461i32 as _);
pub const COMADMIN_E_USERPASSWDNOTVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368492i32 as _);
pub const COMADMIN_E_USER_IN_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367474i32 as _);
pub const COMQC_E_APPLICATION_NOT_QUEUED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146368000i32 as _);
pub const COMQC_E_BAD_MESSAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367996i32 as _);
pub const COMQC_E_NO_IPERSISTSTREAM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367997i32 as _);
pub const COMQC_E_NO_QUEUEABLE_INTERFACES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367999i32 as _);
pub const COMQC_E_QUEUING_SERVICE_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367998i32 as _);
pub const COMQC_E_UNAUTHENTICATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367995i32 as _);
pub const COMQC_E_UNTRUSTED_ENQUEUER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367994i32 as _);
pub const CONTEXT_E_ABORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164158i32 as _);
pub const CONTEXT_E_ABORTING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164157i32 as _);
pub const CONTEXT_E_FIRST: i32 = -2147164160i32;
pub const CONTEXT_E_LAST: i32 = -2147164113i32;
pub const CONTEXT_E_NOCONTEXT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164156i32 as _);
pub const CONTEXT_E_NOJIT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164122i32 as _);
pub const CONTEXT_E_NOTRANSACTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164121i32 as _);
pub const CONTEXT_E_OLDREF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164153i32 as _);
pub const CONTEXT_E_ROLENOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164148i32 as _);
pub const CONTEXT_E_SYNCH_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164154i32 as _);
pub const CONTEXT_E_TMNOTAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164145i32 as _);
pub const CONTEXT_E_WOULD_DEADLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164155i32 as _);
pub const CONTEXT_S_FIRST: i32 = 319488i32;
pub const CONTEXT_S_LAST: i32 = 319535i32;
pub const CONVERT10_E_FIRST: i32 = -2147221056i32;
pub const CONVERT10_E_LAST: i32 = -2147221041i32;
pub const CONVERT10_E_OLESTREAM_BITMAP_TO_DIB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221053i32 as _);
pub const CONVERT10_E_OLESTREAM_FMT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221054i32 as _);
pub const CONVERT10_E_OLESTREAM_GET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221056i32 as _);
pub const CONVERT10_E_OLESTREAM_PUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221055i32 as _);
pub const CONVERT10_E_STG_DIB_TO_BITMAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221050i32 as _);
pub const CONVERT10_E_STG_FMT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221052i32 as _);
pub const CONVERT10_E_STG_NO_STD_STREAM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221051i32 as _);
pub const CONVERT10_S_FIRST: i32 = 262592i32;
pub const CONVERT10_S_LAST: i32 = 262607i32;
pub const CONVERT10_S_NO_PRESENTATION: ::windows::core::HRESULT = ::windows::core::HRESULT(262592i32 as _);
pub const CO_E_ACCESSCHECKFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417814i32 as _);
pub const CO_E_ACESINWRONGORDER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417798i32 as _);
pub const CO_E_ACNOTINITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417793i32 as _);
pub const CO_E_ACTIVATIONFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164127i32 as _);
pub const CO_E_ACTIVATIONFAILED_CATALOGERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164125i32 as _);
pub const CO_E_ACTIVATIONFAILED_EVENTLOGGED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164126i32 as _);
pub const CO_E_ACTIVATIONFAILED_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164124i32 as _);
pub const CO_E_ALREADYINITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221007i32 as _);
pub const CO_E_APPDIDNTREG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220994i32 as _);
pub const CO_E_APPNOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221003i32 as _);
pub const CO_E_APPSINGLEUSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221002i32 as _);
pub const CO_E_ASYNC_WORK_REJECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467223i32 as _);
pub const CO_E_ATTEMPT_TO_CREATE_OUTSIDE_CLIENT_CONTEXT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467228i32 as _);
pub const CO_E_BAD_PATH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959356i32 as _);
pub const CO_E_BAD_SERVER_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467244i32 as _);
pub const CO_E_CALL_OUT_OF_TX_SCOPE_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164112i32 as _);
pub const CO_E_CANCEL_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417792i32 as _);
pub const CO_E_CANTDETERMINECLASS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221006i32 as _);
pub const CO_E_CANT_REMOTE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467245i32 as _);
pub const CO_E_CLASSSTRING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221005i32 as _);
pub const CO_E_CLASS_CREATE_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959359i32 as _);
pub const CO_E_CLASS_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467225i32 as _);
pub const CO_E_CLRNOTAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467224i32 as _);
pub const CO_E_CLSREG_INCONSISTENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467233i32 as _);
pub const CO_E_CONVERSIONFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417810i32 as _);
pub const CO_E_CREATEPROCESS_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467240i32 as _);
pub const CO_E_DBERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164117i32 as _);
pub const CO_E_DECODEFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417795i32 as _);
pub const CO_E_DLLNOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221000i32 as _);
pub const CO_E_ELEVATION_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959337i32 as _);
pub const CO_E_ERRORINAPP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221001i32 as _);
pub const CO_E_ERRORINDLL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220999i32 as _);
pub const CO_E_EXCEEDSYSACLLIMIT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417799i32 as _);
pub const CO_E_EXIT_TRANSACTION_SCOPE_NOT_CALLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164111i32 as _);
pub const CO_E_FAILEDTOCLOSEHANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417800i32 as _);
pub const CO_E_FAILEDTOCREATEFILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417801i32 as _);
pub const CO_E_FAILEDTOGENUUID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417802i32 as _);
pub const CO_E_FAILEDTOGETSECCTX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417820i32 as _);
pub const CO_E_FAILEDTOGETTOKENINFO: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417818i32 as _);
pub const CO_E_FAILEDTOGETWINDIR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417804i32 as _);
pub const CO_E_FAILEDTOIMPERSONATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417821i32 as _);
pub const CO_E_FAILEDTOOPENPROCESSTOKEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417796i32 as _);
pub const CO_E_FAILEDTOOPENTHREADTOKEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417819i32 as _);
pub const CO_E_FAILEDTOQUERYCLIENTBLANKET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417816i32 as _);
pub const CO_E_FAILEDTOSETDACL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417815i32 as _);
pub const CO_E_FIRST: i32 = -2147221008i32;
pub const CO_E_IIDREG_INCONSISTENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467232i32 as _);
pub const CO_E_IIDSTRING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221004i32 as _);
pub const CO_E_INCOMPATIBLESTREAMVERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417797i32 as _);
pub const CO_E_INITIALIZATIONFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164123i32 as _);
pub const CO_E_INIT_CLASS_CACHE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467255i32 as _);
pub const CO_E_INIT_MEMORY_ALLOCATOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467256i32 as _);
pub const CO_E_INIT_ONLY_SINGLE_THREADED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467246i32 as _);
pub const CO_E_INIT_RPC_CHANNEL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467254i32 as _);
pub const CO_E_INIT_SCM_EXEC_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467247i32 as _);
pub const CO_E_INIT_SCM_FILE_MAPPING_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467249i32 as _);
pub const CO_E_INIT_SCM_MAP_VIEW_OF_FILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467248i32 as _);
pub const CO_E_INIT_SCM_MUTEX_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467250i32 as _);
pub const CO_E_INIT_SHARED_ALLOCATOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467257i32 as _);
pub const CO_E_INIT_TLS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467258i32 as _);
pub const CO_E_INIT_TLS_CHANNEL_CONTROL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467252i32 as _);
pub const CO_E_INIT_TLS_SET_CHANNEL_CONTROL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467253i32 as _);
pub const CO_E_INIT_UNACCEPTED_USER_ALLOCATOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467251i32 as _);
pub const CO_E_INVALIDSID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417811i32 as _);
pub const CO_E_ISOLEVELMISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164113i32 as _);
pub const CO_E_LAST: i32 = -2147220993i32;
pub const CO_E_LAUNCH_PERMSSION_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467237i32 as _);
pub const CO_E_LOOKUPACCNAMEFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417806i32 as _);
pub const CO_E_LOOKUPACCSIDFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417808i32 as _);
pub const CO_E_MALFORMED_SPN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467213i32 as _);
pub const CO_E_MISSING_DISPLAYNAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959339i32 as _);
pub const CO_E_MSI_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467229i32 as _);
pub const CO_E_NETACCESSAPIFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417813i32 as _);
pub const CO_E_NOCOOKIES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164118i32 as _);
pub const CO_E_NOIISINTRINSICS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164119i32 as _);
pub const CO_E_NOMATCHINGNAMEFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417807i32 as _);
pub const CO_E_NOMATCHINGSIDFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417809i32 as _);
pub const CO_E_NOSYNCHRONIZATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164114i32 as _);
pub const CO_E_NOTCONSTRUCTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164115i32 as _);
pub const CO_E_NOTINITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221008i32 as _);
pub const CO_E_NOTPOOLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164116i32 as _);
pub const CO_E_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467231i32 as _);
pub const CO_E_NO_SECCTX_IN_ACTIVATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467221i32 as _);
pub const CO_E_OBJISREG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220996i32 as _);
pub const CO_E_OBJNOTCONNECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220995i32 as _);
pub const CO_E_OBJNOTREG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220997i32 as _);
pub const CO_E_OBJSRV_RPC_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959354i32 as _);
pub const CO_E_OLE1DDE_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467242i32 as _);
pub const CO_E_PATHTOOLONG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417803i32 as _);
pub const CO_E_PREMATURE_STUB_RUNDOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467211i32 as _);
pub const CO_E_RELEASED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220993i32 as _);
pub const CO_E_RELOAD_DLL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467230i32 as _);
pub const CO_E_REMOTE_COMMUNICATION_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467235i32 as _);
pub const CO_E_RUNAS_CREATEPROCESS_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467239i32 as _);
pub const CO_E_RUNAS_LOGON_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467238i32 as _);
pub const CO_E_RUNAS_SYNTAX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467241i32 as _);
pub const CO_E_RUNAS_VALUE_MUST_BE_AAA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959338i32 as _);
pub const CO_E_SCM_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959358i32 as _);
pub const CO_E_SCM_RPC_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959357i32 as _);
pub const CO_E_SERVER_EXEC_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959355i32 as _);
pub const CO_E_SERVER_INIT_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467222i32 as _);
pub const CO_E_SERVER_NOT_PAUSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467226i32 as _);
pub const CO_E_SERVER_PAUSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467227i32 as _);
pub const CO_E_SERVER_START_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467234i32 as _);
pub const CO_E_SERVER_STOPPING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959352i32 as _);
pub const CO_E_SETSERLHNDLFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417805i32 as _);
pub const CO_E_START_SERVICE_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467236i32 as _);
pub const CO_E_SXS_CONFIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467214i32 as _);
pub const CO_E_THREADINGMODEL_CHANGED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147164120i32 as _);
pub const CO_E_THREADPOOL_CONFIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467215i32 as _);
pub const CO_E_TRACKER_CONFIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467216i32 as _);
pub const CO_E_TRUSTEEDOESNTMATCHCLIENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417817i32 as _);
pub const CO_E_UNREVOKED_REGISTRATION_ON_APARTMENT_SHUTDOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467212i32 as _);
pub const CO_E_WRONGOSFORAPP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220998i32 as _);
pub const CO_E_WRONGTRUSTEENAMESYNTAX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417812i32 as _);
pub const CO_E_WRONG_SERVER_IDENTITY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467243i32 as _);
pub const CO_S_FIRST: i32 = 262640i32;
pub const CO_S_LAST: i32 = 262655i32;
pub const CO_S_MACHINENAMENOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(524307i32 as _);
pub const CO_S_NOTALLINTERFACES: ::windows::core::HRESULT = ::windows::core::HRESULT(524306i32 as _);
pub const CRYPT_E_ALREADY_DECRYPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889719i32 as _);
pub const CRYPT_E_ASN1_BADARGS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881271i32 as _);
pub const CRYPT_E_ASN1_BADPDU: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881272i32 as _);
pub const CRYPT_E_ASN1_BADREAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881270i32 as _);
pub const CRYPT_E_ASN1_BADTAG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881269i32 as _);
pub const CRYPT_E_ASN1_CHOICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881268i32 as _);
pub const CRYPT_E_ASN1_CONSTRAINT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881275i32 as _);
pub const CRYPT_E_ASN1_CORRUPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881277i32 as _);
pub const CRYPT_E_ASN1_EOD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881278i32 as _);
pub const CRYPT_E_ASN1_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881280i32 as _);
pub const CRYPT_E_ASN1_EXTENDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881023i32 as _);
pub const CRYPT_E_ASN1_INTERNAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881279i32 as _);
pub const CRYPT_E_ASN1_LARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881276i32 as _);
pub const CRYPT_E_ASN1_MEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881274i32 as _);
pub const CRYPT_E_ASN1_NOEOD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881022i32 as _);
pub const CRYPT_E_ASN1_NYI: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881228i32 as _);
pub const CRYPT_E_ASN1_OVERFLOW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881273i32 as _);
pub const CRYPT_E_ASN1_PDU_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881229i32 as _);
pub const CRYPT_E_ASN1_RULE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881267i32 as _);
pub const CRYPT_E_ASN1_UTF8: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881266i32 as _);
pub const CRYPT_E_ATTRIBUTES_MISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889713i32 as _);
pub const CRYPT_E_AUTH_ATTR_MISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889722i32 as _);
pub const CRYPT_E_BAD_ENCODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885630i32 as _);
pub const CRYPT_E_BAD_LEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885631i32 as _);
pub const CRYPT_E_BAD_MSG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885619i32 as _);
pub const CRYPT_E_CONTROL_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889716i32 as _);
pub const CRYPT_E_DELETED_PREV: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885624i32 as _);
pub const CRYPT_E_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885627i32 as _);
pub const CRYPT_E_FILERESIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885595i32 as _);
pub const CRYPT_E_FILE_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885629i32 as _);
pub const CRYPT_E_HASH_VALUE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889721i32 as _);
pub const CRYPT_E_INVALID_IA5_STRING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885598i32 as _);
pub const CRYPT_E_INVALID_INDEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889720i32 as _);
pub const CRYPT_E_INVALID_MSG_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889724i32 as _);
pub const CRYPT_E_INVALID_NUMERIC_STRING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885600i32 as _);
pub const CRYPT_E_INVALID_PRINTABLE_STRING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885599i32 as _);
pub const CRYPT_E_INVALID_X500_STRING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885597i32 as _);
pub const CRYPT_E_ISSUER_SERIALNUMBER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889715i32 as _);
pub const CRYPT_E_MISSING_PUBKEY_PARA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885588i32 as _);
pub const CRYPT_E_MSG_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889727i32 as _);
pub const CRYPT_E_NOT_CHAR_STRING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885596i32 as _);
pub const CRYPT_E_NOT_DECRYPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889718i32 as _);
pub const CRYPT_E_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885628i32 as _);
pub const CRYPT_E_NOT_IN_CTL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885590i32 as _);
pub const CRYPT_E_NOT_IN_REVOCATION_DATABASE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885612i32 as _);
pub const CRYPT_E_NO_DECRYPT_CERT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885620i32 as _);
pub const CRYPT_E_NO_KEY_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885621i32 as _);
pub const CRYPT_E_NO_MATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885623i32 as _);
pub const CRYPT_E_NO_PROVIDER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885626i32 as _);
pub const CRYPT_E_NO_REVOCATION_CHECK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885614i32 as _);
pub const CRYPT_E_NO_REVOCATION_DLL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885615i32 as _);
pub const CRYPT_E_NO_SIGNER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885618i32 as _);
pub const CRYPT_E_NO_TRUSTED_SIGNER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885589i32 as _);
pub const CRYPT_E_NO_VERIFY_USAGE_CHECK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885592i32 as _);
pub const CRYPT_E_NO_VERIFY_USAGE_DLL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885593i32 as _);
pub const CRYPT_E_OBJECT_LOCATOR_OBJECT_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885587i32 as _);
pub const CRYPT_E_OID_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889725i32 as _);
pub const CRYPT_E_OSS_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881536i32 as _);
pub const CRYPT_E_PENDING_CLOSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885617i32 as _);
pub const CRYPT_E_RECIPIENT_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889717i32 as _);
pub const CRYPT_E_REVOCATION_OFFLINE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885613i32 as _);
pub const CRYPT_E_REVOKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885616i32 as _);
pub const CRYPT_E_SECURITY_SETTINGS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885594i32 as _);
pub const CRYPT_E_SELF_SIGNED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885625i32 as _);
pub const CRYPT_E_SIGNER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889714i32 as _);
pub const CRYPT_E_STREAM_INSUFFICIENT_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889711i32 as _);
pub const CRYPT_E_STREAM_MSG_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889712i32 as _);
pub const CRYPT_E_UNEXPECTED_ENCODING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889723i32 as _);
pub const CRYPT_E_UNEXPECTED_MSG_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885622i32 as _);
pub const CRYPT_E_UNKNOWN_ALGO: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146889726i32 as _);
pub const CRYPT_E_VERIFY_USAGE_OFFLINE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146885591i32 as _);
pub const CRYPT_I_NEW_PROTECTION_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(593938i32 as _);
pub const CS_E_ADMIN_LIMIT_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221139i32 as _);
pub const CS_E_CLASS_NOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221146i32 as _);
pub const CS_E_FIRST: i32 = -2147221148i32;
pub const CS_E_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221137i32 as _);
pub const CS_E_INVALID_PATH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221141i32 as _);
pub const CS_E_INVALID_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221145i32 as _);
pub const CS_E_LAST: i32 = -2147221137i32;
pub const CS_E_NETWORK_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221140i32 as _);
pub const CS_E_NOT_DELETABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221147i32 as _);
pub const CS_E_NO_CLASSSTORE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221144i32 as _);
pub const CS_E_OBJECT_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221142i32 as _);
pub const CS_E_OBJECT_NOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221143i32 as _);
pub const CS_E_PACKAGE_NOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221148i32 as _);
pub const CS_E_SCHEMA_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221138i32 as _);
#[inline]
pub unsafe fn CloseHandle<'a, Param0: ::windows::core::IntoParam<'a, HANDLE>>(hobject: Param0) -> BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CloseHandle(hobject: HANDLE) -> BOOL;
}
::core::mem::transmute(CloseHandle(hobject.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn CompareObjectHandles<'a, Param0: ::windows::core::IntoParam<'a, HANDLE>, Param1: ::windows::core::IntoParam<'a, HANDLE>>(hfirstobjecthandle: Param0, hsecondobjecthandle: Param1) -> BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CompareObjectHandles(hfirstobjecthandle: HANDLE, hsecondobjecthandle: HANDLE) -> BOOL;
}
::core::mem::transmute(CompareObjectHandles(hfirstobjecthandle.into_param().abi(), hsecondobjecthandle.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const D2DERR_BAD_NUMBER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238895i32 as _);
pub const D2DERR_BITMAP_BOUND_AS_TARGET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238875i32 as _);
pub const D2DERR_BITMAP_CANNOT_DRAW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238879i32 as _);
pub const D2DERR_CYCLIC_GRAPH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238880i32 as _);
pub const D2DERR_DISPLAY_FORMAT_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238903i32 as _);
pub const D2DERR_DISPLAY_STATE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238906i32 as _);
pub const D2DERR_EFFECT_IS_NOT_REGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238872i32 as _);
pub const D2DERR_EXCEEDS_MAX_BITMAP_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238883i32 as _);
pub const D2DERR_INCOMPATIBLE_BRUSH_TYPES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238888i32 as _);
pub const D2DERR_INSUFFICIENT_DEVICE_CAPABILITIES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238874i32 as _);
pub const D2DERR_INTERMEDIATE_TOO_LARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238873i32 as _);
pub const D2DERR_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238904i32 as _);
pub const D2DERR_INVALID_CALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238902i32 as _);
pub const D2DERR_INVALID_GLYPH_IMAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238866i32 as _);
pub const D2DERR_INVALID_GRAPH_CONFIGURATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238882i32 as _);
pub const D2DERR_INVALID_INTERNAL_GRAPH_CONFIGURATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238881i32 as _);
pub const D2DERR_INVALID_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238871i32 as _);
pub const D2DERR_INVALID_TARGET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238876i32 as _);
pub const D2DERR_LAYER_ALREADY_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238893i32 as _);
pub const D2DERR_MAX_TEXTURE_SIZE_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238897i32 as _);
pub const D2DERR_NOT_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238910i32 as _);
pub const D2DERR_NO_HARDWARE_DEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238901i32 as _);
pub const D2DERR_NO_SUBPROPERTIES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238870i32 as _);
pub const D2DERR_ORIGINAL_TARGET_NOT_BOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238877i32 as _);
pub const D2DERR_OUTSTANDING_BITMAP_REFERENCES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238878i32 as _);
pub const D2DERR_POP_CALL_DID_NOT_MATCH_PUSH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238892i32 as _);
pub const D2DERR_PRINT_FORMAT_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238868i32 as _);
pub const D2DERR_PRINT_JOB_CLOSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238869i32 as _);
pub const D2DERR_PUSH_POP_UNBALANCED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238890i32 as _);
pub const D2DERR_RECREATE_TARGET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238900i32 as _);
pub const D2DERR_RENDER_TARGET_HAS_LAYER_OR_CLIPRECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238889i32 as _);
pub const D2DERR_SCANNER_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238908i32 as _);
pub const D2DERR_SCREEN_ACCESS_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238907i32 as _);
pub const D2DERR_SHADER_COMPILE_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238898i32 as _);
pub const D2DERR_TARGET_NOT_GDI_COMPATIBLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238886i32 as _);
pub const D2DERR_TEXT_EFFECT_IS_WRONG_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238885i32 as _);
pub const D2DERR_TEXT_RENDERER_NOT_RELEASED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238884i32 as _);
pub const D2DERR_TOO_MANY_SHADER_ELEMENTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238899i32 as _);
pub const D2DERR_TOO_MANY_TRANSFORM_INPUTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238867i32 as _);
pub const D2DERR_UNSUPPORTED_OPERATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238909i32 as _);
pub const D2DERR_UNSUPPORTED_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238896i32 as _);
pub const D2DERR_WIN32_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238887i32 as _);
pub const D2DERR_WRONG_FACTORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238894i32 as _);
pub const D2DERR_WRONG_RESOURCE_DOMAIN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238891i32 as _);
pub const D2DERR_WRONG_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238911i32 as _);
pub const D2DERR_ZERO_VECTOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003238905i32 as _);
pub const D3D10_ERROR_FILE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2005336062i32 as _);
pub const D3D10_ERROR_TOO_MANY_UNIQUE_STATE_OBJECTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2005336063i32 as _);
pub const D3D11_ERROR_DEFERRED_CONTEXT_MAP_WITHOUT_INITIAL_DISCARD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2005139452i32 as _);
pub const D3D11_ERROR_FILE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2005139454i32 as _);
pub const D3D11_ERROR_TOO_MANY_UNIQUE_STATE_OBJECTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2005139455i32 as _);
pub const D3D11_ERROR_TOO_MANY_UNIQUE_VIEW_OBJECTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2005139453i32 as _);
pub const D3D12_ERROR_ADAPTER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2005008383i32 as _);
pub const D3D12_ERROR_DRIVER_VERSION_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2005008382i32 as _);
pub const D3D12_ERROR_INVALID_REDIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2005008381i32 as _);
pub const DATA_E_FIRST: i32 = -2147221200i32;
pub const DATA_E_LAST: i32 = -2147221185i32;
pub const DATA_S_FIRST: i32 = 262448i32;
pub const DATA_S_LAST: i32 = 262463i32;
pub const DATA_S_SAMEFORMATETC: ::windows::core::HRESULT = ::windows::core::HRESULT(262448i32 as _);
pub const DBG_APP_NOT_IDLE: NTSTATUS = NTSTATUS(-1073676286i32 as _);
pub const DBG_COMMAND_EXCEPTION: NTSTATUS = NTSTATUS(1073807369i32 as _);
pub const DBG_CONTINUE: NTSTATUS = NTSTATUS(65538i32 as _);
pub const DBG_CONTROL_BREAK: NTSTATUS = NTSTATUS(1073807368i32 as _);
pub const DBG_CONTROL_C: NTSTATUS = NTSTATUS(1073807365i32 as _);
pub const DBG_EXCEPTION_HANDLED: NTSTATUS = NTSTATUS(65537i32 as _);
pub const DBG_EXCEPTION_NOT_HANDLED: NTSTATUS = NTSTATUS(-2147418111i32 as _);
pub const DBG_NO_STATE_CHANGE: NTSTATUS = NTSTATUS(-1073676287i32 as _);
pub const DBG_PRINTEXCEPTION_C: NTSTATUS = NTSTATUS(1073807366i32 as _);
pub const DBG_PRINTEXCEPTION_WIDE_C: NTSTATUS = NTSTATUS(1073807370i32 as _);
pub const DBG_REPLY_LATER: NTSTATUS = NTSTATUS(1073807361i32 as _);
pub const DBG_RIPEXCEPTION: NTSTATUS = NTSTATUS(1073807367i32 as _);
pub const DBG_TERMINATE_PROCESS: NTSTATUS = NTSTATUS(1073807364i32 as _);
pub const DBG_TERMINATE_THREAD: NTSTATUS = NTSTATUS(1073807363i32 as _);
pub const DBG_UNABLE_TO_PROVIDE_HANDLE: NTSTATUS = NTSTATUS(1073807362i32 as _);
pub const DCOMPOSITION_ERROR_SURFACE_BEING_RENDERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302399i32 as _);
pub const DCOMPOSITION_ERROR_SURFACE_NOT_BEING_RENDERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302398i32 as _);
pub const DCOMPOSITION_ERROR_WINDOW_ALREADY_COMPOSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302400i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DECIMAL {
pub wReserved: u16,
pub Anonymous1: DECIMAL_0,
pub Hi32: u32,
pub Anonymous2: DECIMAL_1,
}
impl DECIMAL {}
impl ::core::default::Default for DECIMAL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DECIMAL {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DECIMAL {}
unsafe impl ::windows::core::Abi for DECIMAL {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union DECIMAL_0 {
pub Anonymous: DECIMAL_0_0,
pub signscale: u16,
}
impl DECIMAL_0 {}
impl ::core::default::Default for DECIMAL_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DECIMAL_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DECIMAL_0 {}
unsafe impl ::windows::core::Abi for DECIMAL_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DECIMAL_0_0 {
pub scale: u8,
pub sign: u8,
}
impl DECIMAL_0_0 {}
impl ::core::default::Default for DECIMAL_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DECIMAL_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("scale", &self.scale).field("sign", &self.sign).finish()
}
}
impl ::core::cmp::PartialEq for DECIMAL_0_0 {
fn eq(&self, other: &Self) -> bool {
self.scale == other.scale && self.sign == other.sign
}
}
impl ::core::cmp::Eq for DECIMAL_0_0 {}
unsafe impl ::windows::core::Abi for DECIMAL_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union DECIMAL_1 {
pub Anonymous: DECIMAL_1_0,
pub Lo64: u64,
}
impl DECIMAL_1 {}
impl ::core::default::Default for DECIMAL_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DECIMAL_1 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DECIMAL_1 {}
unsafe impl ::windows::core::Abi for DECIMAL_1 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DECIMAL_1_0 {
pub Lo32: u32,
pub Mid32: u32,
}
impl DECIMAL_1_0 {}
impl ::core::default::Default for DECIMAL_1_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DECIMAL_1_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("Lo32", &self.Lo32).field("Mid32", &self.Mid32).finish()
}
}
impl ::core::cmp::PartialEq for DECIMAL_1_0 {
fn eq(&self, other: &Self) -> bool {
self.Lo32 == other.Lo32 && self.Mid32 == other.Mid32
}
}
impl ::core::cmp::Eq for DECIMAL_1_0 {}
unsafe impl ::windows::core::Abi for DECIMAL_1_0 {
type Abi = Self;
}
pub const DIGSIG_E_CRYPTO: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762744i32 as _);
pub const DIGSIG_E_DECODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762746i32 as _);
pub const DIGSIG_E_ENCODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762747i32 as _);
pub const DIGSIG_E_EXTENSIBILITY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762745i32 as _);
pub const DISP_E_ARRAYISLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352563i32 as _);
pub const DISP_E_BADCALLEE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352560i32 as _);
pub const DISP_E_BADINDEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352565i32 as _);
pub const DISP_E_BADPARAMCOUNT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352562i32 as _);
pub const DISP_E_BADVARTYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352568i32 as _);
pub const DISP_E_BUFFERTOOSMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352557i32 as _);
pub const DISP_E_DIVBYZERO: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352558i32 as _);
pub const DISP_E_EXCEPTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352567i32 as _);
pub const DISP_E_MEMBERNOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352573i32 as _);
pub const DISP_E_NONAMEDARGS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352569i32 as _);
pub const DISP_E_NOTACOLLECTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352559i32 as _);
pub const DISP_E_OVERFLOW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352566i32 as _);
pub const DISP_E_PARAMNOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352572i32 as _);
pub const DISP_E_PARAMNOTOPTIONAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352561i32 as _);
pub const DISP_E_TYPEMISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352571i32 as _);
pub const DISP_E_UNKNOWNINTERFACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352575i32 as _);
pub const DISP_E_UNKNOWNLCID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352564i32 as _);
pub const DISP_E_UNKNOWNNAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352570i32 as _);
pub const DM_COPY: u32 = 2u32;
pub const DM_IN_BUFFER: u32 = 8u32;
pub const DM_IN_PROMPT: u32 = 4u32;
pub const DM_MODIFY: u32 = 8u32;
pub const DM_OUT_BUFFER: u32 = 2u32;
pub const DM_OUT_DEFAULT: u32 = 1u32;
pub const DM_PROMPT: u32 = 4u32;
pub const DM_UPDATE: u32 = 1u32;
pub const DNS_INFO_ADDED_LOCAL_WINS: i32 = 9753i32;
pub const DNS_INFO_AXFR_COMPLETE: i32 = 9751i32;
pub const DNS_INFO_NO_RECORDS: i32 = 9501i32;
pub const DNS_REQUEST_PENDING: i32 = 9506i32;
pub const DNS_STATUS_CONTINUE_NEEDED: i32 = 9801i32;
pub const DNS_STATUS_DOTTED_NAME: i32 = 9558i32;
pub const DNS_STATUS_FQDN: i32 = 9557i32;
pub const DNS_STATUS_SINGLE_PART_NAME: i32 = 9559i32;
pub const DNS_WARNING_DOMAIN_UNDELETED: i32 = 9716i32;
pub const DNS_WARNING_PTR_CREATE_FAILED: i32 = 9715i32;
pub const DRAGDROP_E_ALREADYREGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221247i32 as _);
pub const DRAGDROP_E_CONCURRENT_DRAG_ATTEMPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221245i32 as _);
pub const DRAGDROP_E_FIRST: i32 = -2147221248i32;
pub const DRAGDROP_E_INVALIDHWND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221246i32 as _);
pub const DRAGDROP_E_LAST: i32 = -2147221233i32;
pub const DRAGDROP_E_NOTREGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221248i32 as _);
pub const DRAGDROP_S_CANCEL: ::windows::core::HRESULT = ::windows::core::HRESULT(262401i32 as _);
pub const DRAGDROP_S_DROP: ::windows::core::HRESULT = ::windows::core::HRESULT(262400i32 as _);
pub const DRAGDROP_S_FIRST: i32 = 262400i32;
pub const DRAGDROP_S_LAST: i32 = 262415i32;
pub const DRAGDROP_S_USEDEFAULTCURSORS: ::windows::core::HRESULT = ::windows::core::HRESULT(262402i32 as _);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DUPLICATE_HANDLE_OPTIONS(pub u32);
pub const DUPLICATE_CLOSE_SOURCE: DUPLICATE_HANDLE_OPTIONS = DUPLICATE_HANDLE_OPTIONS(1u32);
pub const DUPLICATE_SAME_ACCESS: DUPLICATE_HANDLE_OPTIONS = DUPLICATE_HANDLE_OPTIONS(2u32);
impl ::core::convert::From<u32> for DUPLICATE_HANDLE_OPTIONS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DUPLICATE_HANDLE_OPTIONS {
type Abi = Self;
}
impl ::core::ops::BitOr for DUPLICATE_HANDLE_OPTIONS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for DUPLICATE_HANDLE_OPTIONS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for DUPLICATE_HANDLE_OPTIONS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for DUPLICATE_HANDLE_OPTIONS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for DUPLICATE_HANDLE_OPTIONS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const DV_E_CLIPFORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221398i32 as _);
pub const DV_E_DVASPECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221397i32 as _);
pub const DV_E_DVTARGETDEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221403i32 as _);
pub const DV_E_DVTARGETDEVICE_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221396i32 as _);
pub const DV_E_FORMATETC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221404i32 as _);
pub const DV_E_LINDEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221400i32 as _);
pub const DV_E_NOIVIEWOBJECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221395i32 as _);
pub const DV_E_STATDATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221401i32 as _);
pub const DV_E_STGMEDIUM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221402i32 as _);
pub const DV_E_TYMED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221399i32 as _);
pub const DWMERR_CATASTROPHIC_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302654i32 as _);
pub const DWMERR_STATE_TRANSITION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302656i32 as _);
pub const DWMERR_THEME_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302655i32 as _);
pub const DWM_E_ADAPTER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144980987i32 as _);
pub const DWM_E_COMPOSITIONDISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144980991i32 as _);
pub const DWM_E_NOT_QUEUING_PRESENTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144980988i32 as _);
pub const DWM_E_NO_REDIRECTION_SURFACE_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144980989i32 as _);
pub const DWM_E_REMOTING_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144980990i32 as _);
pub const DWM_E_TEXTURE_TOO_LARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144980985i32 as _);
pub const DWM_S_GDI_REDIRECTION_SURFACE: ::windows::core::HRESULT = ::windows::core::HRESULT(2502661i32 as _);
pub const DWM_S_GDI_REDIRECTION_SURFACE_BLT_VIA_GDI: ::windows::core::HRESULT = ::windows::core::HRESULT(2502664i32 as _);
pub const DWRITE_E_ALREADYREGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003283962i32 as _);
pub const DWRITE_E_CACHEFORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003283961i32 as _);
pub const DWRITE_E_CACHEVERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003283960i32 as _);
pub const DWRITE_E_FILEACCESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003283964i32 as _);
pub const DWRITE_E_FILEFORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003283968i32 as _);
pub const DWRITE_E_FILENOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003283965i32 as _);
pub const DWRITE_E_FLOWDIRECTIONCONFLICTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003283957i32 as _);
pub const DWRITE_E_FONTCOLLECTIONOBSOLETE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003283963i32 as _);
pub const DWRITE_E_NOCOLOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003283956i32 as _);
pub const DWRITE_E_NOFONT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003283966i32 as _);
pub const DWRITE_E_TEXTRENDERERINCOMPATIBLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003283958i32 as _);
pub const DWRITE_E_UNEXPECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003283967i32 as _);
pub const DWRITE_E_UNSUPPORTEDOPERATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003283959i32 as _);
pub const DXCORE_ERROR_EVENT_NOT_UNREGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2004877311i32 as _);
pub const DXGI_DDI_ERR_NONEXCLUSIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2005204989i32 as _);
pub const DXGI_DDI_ERR_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2005204990i32 as _);
pub const DXGI_DDI_ERR_WASSTILLDRAWING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2005204991i32 as _);
pub const DXGI_STATUS_CLIPPED: ::windows::core::HRESULT = ::windows::core::HRESULT(142213122i32 as _);
pub const DXGI_STATUS_DDA_WAS_STILL_DRAWING: ::windows::core::HRESULT = ::windows::core::HRESULT(142213130i32 as _);
pub const DXGI_STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(142213126i32 as _);
pub const DXGI_STATUS_MODE_CHANGED: ::windows::core::HRESULT = ::windows::core::HRESULT(142213127i32 as _);
pub const DXGI_STATUS_MODE_CHANGE_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(142213128i32 as _);
pub const DXGI_STATUS_NO_DESKTOP_ACCESS: ::windows::core::HRESULT = ::windows::core::HRESULT(142213125i32 as _);
pub const DXGI_STATUS_NO_REDIRECTION: ::windows::core::HRESULT = ::windows::core::HRESULT(142213124i32 as _);
pub const DXGI_STATUS_OCCLUDED: ::windows::core::HRESULT = ::windows::core::HRESULT(142213121i32 as _);
pub const DXGI_STATUS_PRESENT_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(142213167i32 as _);
pub const DXGI_STATUS_UNOCCLUDED: ::windows::core::HRESULT = ::windows::core::HRESULT(142213129i32 as _);
#[inline]
pub unsafe fn DuplicateHandle<'a, Param0: ::windows::core::IntoParam<'a, HANDLE>, Param1: ::windows::core::IntoParam<'a, HANDLE>, Param2: ::windows::core::IntoParam<'a, HANDLE>, Param5: ::windows::core::IntoParam<'a, BOOL>>(hsourceprocesshandle: Param0, hsourcehandle: Param1, htargetprocesshandle: Param2, lptargethandle: *mut HANDLE, dwdesiredaccess: u32, binherithandle: Param5, dwoptions: DUPLICATE_HANDLE_OPTIONS) -> BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DuplicateHandle(hsourceprocesshandle: HANDLE, hsourcehandle: HANDLE, htargetprocesshandle: HANDLE, lptargethandle: *mut HANDLE, dwdesiredaccess: u32, binherithandle: BOOL, dwoptions: DUPLICATE_HANDLE_OPTIONS) -> BOOL;
}
::core::mem::transmute(DuplicateHandle(hsourceprocesshandle.into_param().abi(), hsourcehandle.into_param().abi(), htargetprocesshandle.into_param().abi(), ::core::mem::transmute(lptargethandle), ::core::mem::transmute(dwdesiredaccess), binherithandle.into_param().abi(), ::core::mem::transmute(dwoptions)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const EAS_E_ADMINS_CANNOT_CHANGE_PASSWORD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141913080i32 as _);
pub const EAS_E_ADMINS_HAVE_BLANK_PASSWORD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141913081i32 as _);
pub const EAS_E_CONNECTED_ADMINS_NEED_TO_CHANGE_PASSWORD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141913077i32 as _);
pub const EAS_E_CURRENT_CONNECTED_USER_NEED_TO_CHANGE_PASSWORD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141913075i32 as _);
pub const EAS_E_CURRENT_USER_HAS_BLANK_PASSWORD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141913084i32 as _);
pub const EAS_E_LOCAL_CONTROLLED_USERS_CANNOT_CHANGE_PASSWORD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141913079i32 as _);
pub const EAS_E_PASSWORD_POLICY_NOT_ENFORCEABLE_FOR_CONNECTED_ADMINS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141913078i32 as _);
pub const EAS_E_PASSWORD_POLICY_NOT_ENFORCEABLE_FOR_CURRENT_CONNECTED_USER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141913076i32 as _);
pub const EAS_E_POLICY_COMPLIANT_WITH_ACTIONS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141913086i32 as _);
pub const EAS_E_POLICY_NOT_MANAGED_BY_OS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141913087i32 as _);
pub const EAS_E_REQUESTED_POLICY_NOT_ENFORCEABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141913085i32 as _);
pub const EAS_E_REQUESTED_POLICY_PASSWORD_EXPIRATION_INCOMPATIBLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141913083i32 as _);
pub const EAS_E_USER_CANNOT_CHANGE_PASSWORD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141913082i32 as _);
pub const ENUM_E_FIRST: i32 = -2147221072i32;
pub const ENUM_E_LAST: i32 = -2147221057i32;
pub const ENUM_S_FIRST: i32 = 262576i32;
pub const ENUM_S_LAST: i32 = 262591i32;
pub const EPT_NT_CANT_CREATE: NTSTATUS = NTSTATUS(-1073610676i32 as _);
pub const EPT_NT_CANT_PERFORM_OP: NTSTATUS = NTSTATUS(-1073610699i32 as _);
pub const EPT_NT_INVALID_ENTRY: NTSTATUS = NTSTATUS(-1073610700i32 as _);
pub const EPT_NT_NOT_REGISTERED: NTSTATUS = NTSTATUS(-1073610698i32 as _);
pub const ERROR_ALLOWED_PORT_TYPE_RESTRICTION: u32 = 941u32;
pub const ERROR_ALL_SIDS_FILTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073151998i32 as _);
pub const ERROR_ALREADY_CONNECTED: u32 = 901u32;
pub const ERROR_ALREADY_CONNECTING: u32 = 910u32;
pub const ERROR_ATTRIBUTE_NOT_PRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138898422i32 as _);
pub const ERROR_AUDITING_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073151999i32 as _);
pub const ERROR_AUTHENTICATOR_MISMATCH: u32 = 955u32;
pub const ERROR_AUTH_PROTOCOL_REJECTED: u32 = 917u32;
pub const ERROR_AUTH_PROTOCOL_RESTRICTION: u32 = 942u32;
pub const ERROR_AUTH_SERVER_TIMEOUT: u32 = 930u32;
pub const ERROR_BAP_DISCONNECTED: u32 = 936u32;
pub const ERROR_BAP_REQUIRED: u32 = 943u32;
pub const ERROR_BIZRULES_NOT_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073151997i32 as _);
pub const ERROR_CLIENT_INTERFACE_ALREADY_EXISTS: u32 = 915u32;
pub const ERROR_CLIP_DEVICE_LICENSE_MISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-1058406397i32 as _);
pub const ERROR_CLIP_KEYHOLDER_LICENSE_MISSING_OR_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-1058406395i32 as _);
pub const ERROR_CLIP_LICENSE_DEVICE_ID_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-1058406390i32 as _);
pub const ERROR_CLIP_LICENSE_EXPIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1058406394i32 as _);
pub const ERROR_CLIP_LICENSE_HARDWARE_ID_OUT_OF_TOLERANCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1058406391i32 as _);
pub const ERROR_CLIP_LICENSE_INVALID_SIGNATURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1058406396i32 as _);
pub const ERROR_CLIP_LICENSE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1058406398i32 as _);
pub const ERROR_CLIP_LICENSE_NOT_SIGNED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1058406392i32 as _);
pub const ERROR_CLIP_LICENSE_SIGNED_BY_UNKNOWN_SOURCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1058406393i32 as _);
pub const ERROR_CRED_REQUIRES_CONFIRMATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865127i32 as _);
pub const ERROR_DBG_ATTACH_PROCESS_FAILURE_LOCKDOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2135949310i32 as _);
pub const ERROR_DBG_CONNECT_SERVER_FAILURE_LOCKDOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2135949309i32 as _);
pub const ERROR_DBG_CREATE_PROCESS_FAILURE_LOCKDOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2135949311i32 as _);
pub const ERROR_DBG_START_SERVER_FAILURE_LOCKDOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2135949308i32 as _);
pub const ERROR_DDM_NOT_RUNNING: u32 = 903u32;
pub const ERROR_DIALIN_HOURS_RESTRICTION: u32 = 940u32;
pub const ERROR_DIALOUT_HOURS_RESTRICTION: u32 = 944u32;
pub const ERROR_FLT_ALREADY_ENLISTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452005i32 as _);
pub const ERROR_FLT_CBDQ_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452018i32 as _);
pub const ERROR_FLT_CONTEXT_ALLOCATION_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452010i32 as _);
pub const ERROR_FLT_CONTEXT_ALREADY_DEFINED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452030i32 as _);
pub const ERROR_FLT_CONTEXT_ALREADY_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452004i32 as _);
pub const ERROR_FLT_DELETING_OBJECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452021i32 as _);
pub const ERROR_FLT_DISALLOW_FAST_IO: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452028i32 as _);
pub const ERROR_FLT_DO_NOT_ATTACH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452017i32 as _);
pub const ERROR_FLT_DO_NOT_DETACH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452016i32 as _);
pub const ERROR_FLT_DUPLICATE_ENTRY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452019i32 as _);
pub const ERROR_FLT_FILTER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452013i32 as _);
pub const ERROR_FLT_FILTER_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452024i32 as _);
pub const ERROR_FLT_INSTANCE_ALTITUDE_COLLISION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452015i32 as _);
pub const ERROR_FLT_INSTANCE_NAME_COLLISION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452014i32 as _);
pub const ERROR_FLT_INSTANCE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452011i32 as _);
pub const ERROR_FLT_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452022i32 as _);
pub const ERROR_FLT_INVALID_ASYNCHRONOUS_REQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452029i32 as _);
pub const ERROR_FLT_INVALID_CONTEXT_REGISTRATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452009i32 as _);
pub const ERROR_FLT_INVALID_NAME_REQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452027i32 as _);
pub const ERROR_FLT_IO_COMPLETE: ::windows::core::HRESULT = ::windows::core::HRESULT(2031617i32 as _);
pub const ERROR_FLT_MUST_BE_NONPAGED_POOL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452020i32 as _);
pub const ERROR_FLT_NAME_CACHE_MISS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452008i32 as _);
pub const ERROR_FLT_NOT_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452025i32 as _);
pub const ERROR_FLT_NOT_SAFE_TO_POST_OPERATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452026i32 as _);
pub const ERROR_FLT_NO_DEVICE_OBJECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452007i32 as _);
pub const ERROR_FLT_NO_HANDLER_DEFINED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452031i32 as _);
pub const ERROR_FLT_NO_WAITER_FOR_REPLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452000i32 as _);
pub const ERROR_FLT_POST_OPERATION_CLEANUP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452023i32 as _);
pub const ERROR_FLT_REGISTRATION_BUSY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145451997i32 as _);
pub const ERROR_FLT_VOLUME_ALREADY_MOUNTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452006i32 as _);
pub const ERROR_FLT_VOLUME_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145452012i32 as _);
pub const ERROR_FLT_WCOS_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145451996i32 as _);
pub const ERROR_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242181i32 as _);
pub const ERROR_GRAPHICS_ADAPTER_CHAIN_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242189i32 as _);
pub const ERROR_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242456i32 as _);
pub const ERROR_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242455i32 as _);
pub const ERROR_GRAPHICS_ADAPTER_WAS_RESET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243261i32 as _);
pub const ERROR_GRAPHICS_ALLOCATION_BUSY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243006i32 as _);
pub const ERROR_GRAPHICS_ALLOCATION_CLOSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242990i32 as _);
pub const ERROR_GRAPHICS_ALLOCATION_CONTENT_LOST: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242986i32 as _);
pub const ERROR_GRAPHICS_ALLOCATION_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243002i32 as _);
pub const ERROR_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242406i32 as _);
pub const ERROR_GRAPHICS_CANNOTCOLORCONVERT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243256i32 as _);
pub const ERROR_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242429i32 as _);
pub const ERROR_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242999i32 as _);
pub const ERROR_GRAPHICS_CANT_LOCK_MEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243007i32 as _);
pub const ERROR_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242991i32 as _);
pub const ERROR_GRAPHICS_CHAINLINKS_NOT_ENUMERATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242190i32 as _);
pub const ERROR_GRAPHICS_CHAINLINKS_NOT_POWERED_ON: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242187i32 as _);
pub const ERROR_GRAPHICS_CHAINLINKS_NOT_STARTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242188i32 as _);
pub const ERROR_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242239i32 as _);
pub const ERROR_GRAPHICS_CLIENTVIDPN_NOT_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242404i32 as _);
pub const ERROR_GRAPHICS_COPP_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241983i32 as _);
pub const ERROR_GRAPHICS_DATASET_IS_EMPTY: ::windows::core::HRESULT = ::windows::core::HRESULT(2499403i32 as _);
pub const ERROR_GRAPHICS_DDCCI_CURRENT_CURRENT_VALUE_GREATER_THAN_MAXIMUM_VALUE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241768i32 as _);
pub const ERROR_GRAPHICS_DDCCI_INVALID_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241851i32 as _);
pub const ERROR_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241845i32 as _);
pub const ERROR_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241847i32 as _);
pub const ERROR_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241846i32 as _);
pub const ERROR_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241850i32 as _);
pub const ERROR_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241852i32 as _);
pub const ERROR_GRAPHICS_DEPENDABLE_CHILD_STATUS: ::windows::core::HRESULT = ::windows::core::HRESULT(1076241468i32 as _);
pub const ERROR_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241758i32 as _);
pub const ERROR_GRAPHICS_DRIVER_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243255i32 as _);
pub const ERROR_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242459i32 as _);
pub const ERROR_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242465i32 as _);
pub const ERROR_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242467i32 as _);
pub const ERROR_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242424i32 as _);
pub const ERROR_GRAPHICS_GPU_EXCEPTION_ON_DEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242752i32 as _);
pub const ERROR_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241855i32 as _);
pub const ERROR_GRAPHICS_I2C_ERROR_RECEIVING_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241853i32 as _);
pub const ERROR_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241854i32 as _);
pub const ERROR_GRAPHICS_I2C_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241856i32 as _);
pub const ERROR_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242411i32 as _);
pub const ERROR_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242186i32 as _);
pub const ERROR_GRAPHICS_INDIRECT_DISPLAY_ABANDON_SWAPCHAIN: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243246i32 as _);
pub const ERROR_GRAPHICS_INDIRECT_DISPLAY_DEVICE_STOPPED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243245i32 as _);
pub const ERROR_GRAPHICS_INSUFFICIENT_DMA_BUFFER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243263i32 as _);
pub const ERROR_GRAPHICS_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241753i32 as _);
pub const ERROR_GRAPHICS_INVALID_ACTIVE_REGION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242485i32 as _);
pub const ERROR_GRAPHICS_INVALID_ALLOCATION_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242988i32 as _);
pub const ERROR_GRAPHICS_INVALID_ALLOCATION_INSTANCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242989i32 as _);
pub const ERROR_GRAPHICS_INVALID_ALLOCATION_USAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242992i32 as _);
pub const ERROR_GRAPHICS_INVALID_CLIENT_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242405i32 as _);
pub const ERROR_GRAPHICS_INVALID_COLORBASIS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242434i32 as _);
pub const ERROR_GRAPHICS_INVALID_COPYPROTECTION_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242417i32 as _);
pub const ERROR_GRAPHICS_INVALID_DISPLAY_ADAPTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243262i32 as _);
pub const ERROR_GRAPHICS_INVALID_DRIVER_MODEL: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243260i32 as _);
pub const ERROR_GRAPHICS_INVALID_FREQUENCY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242486i32 as _);
pub const ERROR_GRAPHICS_INVALID_GAMMA_RAMP: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242425i32 as _);
pub const ERROR_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242410i32 as _);
pub const ERROR_GRAPHICS_INVALID_MONITORDESCRIPTOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242453i32 as _);
pub const ERROR_GRAPHICS_INVALID_MONITORDESCRIPTORSET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242454i32 as _);
pub const ERROR_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242409i32 as _);
pub const ERROR_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242468i32 as _);
pub const ERROR_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242469i32 as _);
pub const ERROR_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242408i32 as _);
pub const ERROR_GRAPHICS_INVALID_MONITOR_SOURCEMODESET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242463i32 as _);
pub const ERROR_GRAPHICS_INVALID_MONITOR_SOURCE_MODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242462i32 as _);
pub const ERROR_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242427i32 as _);
pub const ERROR_GRAPHICS_INVALID_PATH_CONTENT_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242418i32 as _);
pub const ERROR_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242428i32 as _);
pub const ERROR_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241844i32 as _);
pub const ERROR_GRAPHICS_INVALID_PIXELFORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242435i32 as _);
pub const ERROR_GRAPHICS_INVALID_PIXELVALUEACCESSMODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242433i32 as _);
pub const ERROR_GRAPHICS_INVALID_POINTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241756i32 as _);
pub const ERROR_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242438i32 as _);
pub const ERROR_GRAPHICS_INVALID_SCANLINE_ORDERING: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242414i32 as _);
pub const ERROR_GRAPHICS_INVALID_STRIDE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242436i32 as _);
pub const ERROR_GRAPHICS_INVALID_TOTAL_REGION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242484i32 as _);
pub const ERROR_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242475i32 as _);
pub const ERROR_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242474i32 as _);
pub const ERROR_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242492i32 as _);
pub const ERROR_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242480i32 as _);
pub const ERROR_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242491i32 as _);
pub const ERROR_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242479i32 as _);
pub const ERROR_GRAPHICS_INVALID_VIDPN: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242493i32 as _);
pub const ERROR_GRAPHICS_INVALID_VIDPN_PRESENT_PATH: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242471i32 as _);
pub const ERROR_GRAPHICS_INVALID_VIDPN_SOURCEMODESET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242488i32 as _);
pub const ERROR_GRAPHICS_INVALID_VIDPN_TARGETMODESET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242487i32 as _);
pub const ERROR_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242449i32 as _);
pub const ERROR_GRAPHICS_INVALID_VIDPN_TOPOLOGY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242496i32 as _);
pub const ERROR_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242419i32 as _);
pub const ERROR_GRAPHICS_INVALID_VISIBLEREGION_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242437i32 as _);
pub const ERROR_GRAPHICS_LEADLINK_NOT_ENUMERATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242191i32 as _);
pub const ERROR_GRAPHICS_LEADLINK_START_DEFERRED: ::windows::core::HRESULT = ::windows::core::HRESULT(1076241463i32 as _);
pub const ERROR_GRAPHICS_MAX_NUM_PATHS_REACHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242407i32 as _);
pub const ERROR_GRAPHICS_MCA_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241848i32 as _);
pub const ERROR_GRAPHICS_MCA_INVALID_CAPABILITIES_STRING: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241849i32 as _);
pub const ERROR_GRAPHICS_MCA_INVALID_TECHNOLOGY_TYPE_RETURNED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241762i32 as _);
pub const ERROR_GRAPHICS_MCA_INVALID_VCP_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241767i32 as _);
pub const ERROR_GRAPHICS_MCA_MCCS_VERSION_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241765i32 as _);
pub const ERROR_GRAPHICS_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241766i32 as _);
pub const ERROR_GRAPHICS_MCA_UNSUPPORTED_COLOR_TEMPERATURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241761i32 as _);
pub const ERROR_GRAPHICS_MCA_UNSUPPORTED_MCCS_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241764i32 as _);
pub const ERROR_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241757i32 as _);
pub const ERROR_GRAPHICS_MODE_ALREADY_IN_MODESET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242476i32 as _);
pub const ERROR_GRAPHICS_MODE_ID_MUST_BE_UNIQUE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242460i32 as _);
pub const ERROR_GRAPHICS_MODE_NOT_IN_MODESET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242422i32 as _);
pub const ERROR_GRAPHICS_MODE_NOT_PINNED: ::windows::core::HRESULT = ::windows::core::HRESULT(2499335i32 as _);
pub const ERROR_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242451i32 as _);
pub const ERROR_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242450i32 as _);
pub const ERROR_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242452i32 as _);
pub const ERROR_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242444i32 as _);
pub const ERROR_GRAPHICS_MONITOR_NOT_CONNECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242440i32 as _);
pub const ERROR_GRAPHICS_MONITOR_NO_LONGER_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241843i32 as _);
pub const ERROR_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242423i32 as _);
pub const ERROR_GRAPHICS_NOT_A_LINKED_ADAPTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242192i32 as _);
pub const ERROR_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243264i32 as _);
pub const ERROR_GRAPHICS_NOT_POST_DEVICE_DRIVER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242184i32 as _);
pub const ERROR_GRAPHICS_NO_ACTIVE_VIDPN: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242442i32 as _);
pub const ERROR_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242412i32 as _);
pub const ERROR_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242445i32 as _);
pub const ERROR_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241759i32 as _);
pub const ERROR_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242431i32 as _);
pub const ERROR_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241755i32 as _);
pub const ERROR_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET: ::windows::core::HRESULT = ::windows::core::HRESULT(2499404i32 as _);
pub const ERROR_GRAPHICS_NO_PREFERRED_MODE: ::windows::core::HRESULT = ::windows::core::HRESULT(2499358i32 as _);
pub const ERROR_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242461i32 as _);
pub const ERROR_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242470i32 as _);
pub const ERROR_GRAPHICS_NO_VIDEO_MEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243008i32 as _);
pub const ERROR_GRAPHICS_NO_VIDPNMGR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242443i32 as _);
pub const ERROR_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241760i32 as _);
pub const ERROR_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241960i32 as _);
pub const ERROR_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241954i32 as _);
pub const ERROR_GRAPHICS_OPM_HDCP_SRM_NEVER_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241962i32 as _);
pub const ERROR_GRAPHICS_OPM_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241973i32 as _);
pub const ERROR_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241951i32 as _);
pub const ERROR_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241981i32 as _);
pub const ERROR_GRAPHICS_OPM_INVALID_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241972i32 as _);
pub const ERROR_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241955i32 as _);
pub const ERROR_GRAPHICS_OPM_INVALID_SRM: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241966i32 as _);
pub const ERROR_GRAPHICS_OPM_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241984i32 as _);
pub const ERROR_GRAPHICS_OPM_NO_VIDEO_OUTPUTS_EXIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241979i32 as _);
pub const ERROR_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241964i32 as _);
pub const ERROR_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241963i32 as _);
pub const ERROR_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241965i32 as _);
pub const ERROR_GRAPHICS_OPM_RESOLUTION_TOO_HIGH: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241961i32 as _);
pub const ERROR_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241957i32 as _);
pub const ERROR_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241952i32 as _);
pub const ERROR_GRAPHICS_OPM_SPANNING_MODE_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241969i32 as _);
pub const ERROR_GRAPHICS_OPM_THEATER_MODE_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241968i32 as _);
pub const ERROR_GRAPHICS_OPM_VIDEO_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241956i32 as _);
pub const ERROR_GRAPHICS_OPM_VIDEO_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241953i32 as _);
pub const ERROR_GRAPHICS_OPM_VIDEO_OUTPUT_NO_LONGER_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241958i32 as _);
pub const ERROR_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241754i32 as _);
pub const ERROR_GRAPHICS_PARTIAL_DATA_POPULATED: ::windows::core::HRESULT = ::windows::core::HRESULT(1076240394i32 as _);
pub const ERROR_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242477i32 as _);
pub const ERROR_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED: ::windows::core::HRESULT = ::windows::core::HRESULT(2499409i32 as _);
pub const ERROR_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242426i32 as _);
pub const ERROR_GRAPHICS_PATH_NOT_IN_TOPOLOGY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242457i32 as _);
pub const ERROR_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242478i32 as _);
pub const ERROR_GRAPHICS_POLLING_TOO_FREQUENTLY: ::windows::core::HRESULT = ::windows::core::HRESULT(1076241465i32 as _);
pub const ERROR_GRAPHICS_PRESENT_BUFFER_NOT_BOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243248i32 as _);
pub const ERROR_GRAPHICS_PRESENT_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243257i32 as _);
pub const ERROR_GRAPHICS_PRESENT_INVALID_WINDOW: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243249i32 as _);
pub const ERROR_GRAPHICS_PRESENT_MODE_CHANGED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243259i32 as _);
pub const ERROR_GRAPHICS_PRESENT_OCCLUDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243258i32 as _);
pub const ERROR_GRAPHICS_PRESENT_REDIRECTION_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243253i32 as _);
pub const ERROR_GRAPHICS_PRESENT_UNOCCLUDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243252i32 as _);
pub const ERROR_GRAPHICS_PVP_HFS_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241967i32 as _);
pub const ERROR_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241970i32 as _);
pub const ERROR_GRAPHICS_RESOURCES_NOT_RELATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242448i32 as _);
pub const ERROR_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071249944i32 as _);
pub const ERROR_GRAPHICS_SKIP_ALLOCATION_PREPARATION: ::windows::core::HRESULT = ::windows::core::HRESULT(1076240897i32 as _);
pub const ERROR_GRAPHICS_SOURCE_ALREADY_IN_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242473i32 as _);
pub const ERROR_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242447i32 as _);
pub const ERROR_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242439i32 as _);
pub const ERROR_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242240i32 as _);
pub const ERROR_GRAPHICS_STALE_MODESET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242464i32 as _);
pub const ERROR_GRAPHICS_STALE_VIDPN_TOPOLOGY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242441i32 as _);
pub const ERROR_GRAPHICS_START_DEFERRED: ::windows::core::HRESULT = ::windows::core::HRESULT(1076241466i32 as _);
pub const ERROR_GRAPHICS_TARGET_ALREADY_IN_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242472i32 as _);
pub const ERROR_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242446i32 as _);
pub const ERROR_GRAPHICS_TARGET_NOT_IN_TOPOLOGY: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242432i32 as _);
pub const ERROR_GRAPHICS_TOO_MANY_REFERENCES: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243005i32 as _);
pub const ERROR_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242413i32 as _);
pub const ERROR_GRAPHICS_TRY_AGAIN_LATER: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243004i32 as _);
pub const ERROR_GRAPHICS_TRY_AGAIN_NOW: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243003i32 as _);
pub const ERROR_GRAPHICS_UAB_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071241982i32 as _);
pub const ERROR_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242416i32 as _);
pub const ERROR_GRAPHICS_UNKNOWN_CHILD_STATUS: ::windows::core::HRESULT = ::windows::core::HRESULT(1076241455i32 as _);
pub const ERROR_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243001i32 as _);
pub const ERROR_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243000i32 as _);
pub const ERROR_GRAPHICS_VAIL_FAILED_TO_SEND_COMPOSITION_WINDOW_DPI_MESSAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243242i32 as _);
pub const ERROR_GRAPHICS_VAIL_FAILED_TO_SEND_CREATE_SUPERWETINK_MESSAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243244i32 as _);
pub const ERROR_GRAPHICS_VAIL_FAILED_TO_SEND_DESTROY_SUPERWETINK_MESSAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243243i32 as _);
pub const ERROR_GRAPHICS_VAIL_STATE_CHANGED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243247i32 as _);
pub const ERROR_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242458i32 as _);
pub const ERROR_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242490i32 as _);
pub const ERROR_GRAPHICS_VIDPN_SOURCE_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242430i32 as _);
pub const ERROR_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242494i32 as _);
pub const ERROR_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242495i32 as _);
pub const ERROR_GRAPHICS_WINDOWDC_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243251i32 as _);
pub const ERROR_GRAPHICS_WINDOWLESS_PRESENT_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071243250i32 as _);
pub const ERROR_GRAPHICS_WRONG_ALLOCATION_DEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071242987i32 as _);
pub const ERROR_HUNG_DISPLAY_DRIVER_THREAD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144993279i32 as _);
pub const ERROR_IDLE_DISCONNECTED: u32 = 926u32;
pub const ERROR_INTERFACE_ALREADY_EXISTS: u32 = 904u32;
pub const ERROR_INTERFACE_CONFIGURATION: u32 = 912u32;
pub const ERROR_INTERFACE_CONNECTED: u32 = 908u32;
pub const ERROR_INTERFACE_DISABLED: u32 = 916u32;
pub const ERROR_INTERFACE_DISCONNECTED: u32 = 929u32;
pub const ERROR_INTERFACE_HAS_NO_DEVICES: u32 = 925u32;
pub const ERROR_INTERFACE_NOT_CONNECTED: u32 = 906u32;
pub const ERROR_INTERFACE_UNREACHABLE: u32 = 927u32;
pub const ERROR_INVALID_ATTRIBUTE_LENGTH: u32 = 953u32;
pub const ERROR_INVALID_PACKET: u32 = 954u32;
pub const ERROR_INVALID_PACKET_LENGTH_OR_ID: u32 = 952u32;
pub const ERROR_INVALID_RADIUS_RESPONSE: u32 = 939u32;
pub const ERROR_INVALID_SIGNATURE: u32 = 950u32;
pub const ERROR_INVALID_SIGNATURE_LENGTH: u32 = 949u32;
pub const ERROR_IO_PREEMPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1996423167i32 as _);
pub const ERROR_MAX_CLIENT_INTERFACE_LIMIT: u32 = 935u32;
pub const ERROR_MAX_LAN_INTERFACE_LIMIT: u32 = 933u32;
pub const ERROR_MAX_WAN_INTERFACE_LIMIT: u32 = 934u32;
pub const ERROR_MONITOR_INVALID_DESCRIPTOR_CHECKSUM: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071247357i32 as _);
pub const ERROR_MONITOR_INVALID_DETAILED_TIMING_BLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071247351i32 as _);
pub const ERROR_MONITOR_INVALID_MANUFACTURE_DATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071247350i32 as _);
pub const ERROR_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071247354i32 as _);
pub const ERROR_MONITOR_INVALID_STANDARD_TIMING_BLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071247356i32 as _);
pub const ERROR_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071247353i32 as _);
pub const ERROR_MONITOR_NO_DESCRIPTOR: ::windows::core::HRESULT = ::windows::core::HRESULT(2494465i32 as _);
pub const ERROR_MONITOR_NO_MORE_DESCRIPTOR_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071247352i32 as _);
pub const ERROR_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(2494466i32 as _);
pub const ERROR_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1071247355i32 as _);
pub const ERROR_NOT_A_TIERED_VOLUME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138898423i32 as _);
pub const ERROR_NOT_CLIENT_PORT: u32 = 913u32;
pub const ERROR_NOT_ROUTER_PORT: u32 = 914u32;
pub const ERROR_NO_APPLICABLE_APP_LICENSES_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1058406399i32 as _);
pub const ERROR_NO_AUTH_PROTOCOL_AVAILABLE: u32 = 918u32;
pub const ERROR_NO_INTERFACE_CREDENTIALS_SET: u32 = 909u32;
pub const ERROR_NO_RADIUS_SERVERS: u32 = 938u32;
pub const ERROR_NO_SIGNATURE: u32 = 951u32;
pub const ERROR_NO_SUCH_INTERFACE: u32 = 905u32;
pub const ERROR_PEER_REFUSED_AUTH: u32 = 919u32;
pub const ERROR_PORT_LIMIT_REACHED: u32 = 931u32;
pub const ERROR_PPP_SESSION_TIMEOUT: u32 = 932u32;
pub const ERROR_PROTOCOL_ALREADY_INSTALLED: u32 = 948u32;
pub const ERROR_PROTOCOL_STOP_PENDING: u32 = 907u32;
pub const ERROR_QUIC_ALPN_NEG_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143223801i32 as _);
pub const ERROR_QUIC_CONNECTION_IDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143223803i32 as _);
pub const ERROR_QUIC_CONNECTION_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143223802i32 as _);
pub const ERROR_QUIC_HANDSHAKE_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143223808i32 as _);
pub const ERROR_QUIC_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143223805i32 as _);
pub const ERROR_QUIC_PROTOCOL_VIOLATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143223804i32 as _);
pub const ERROR_QUIC_USER_CANCELED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143223806i32 as _);
pub const ERROR_QUIC_VER_NEG_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143223807i32 as _);
pub const ERROR_REMOTEACCESS_NOT_CONFIGURED: u32 = 956u32;
pub const ERROR_REMOTE_ACCT_DISABLED: u32 = 922u32;
pub const ERROR_REMOTE_AUTHENTICATION_FAILURE: u32 = 924u32;
pub const ERROR_REMOTE_NO_DIALIN_PERMISSION: u32 = 920u32;
pub const ERROR_REMOTE_PASSWD_EXPIRED: u32 = 921u32;
pub const ERROR_REMOTE_RESTRICTED_LOGON_HOURS: u32 = 923u32;
pub const ERROR_ROUTER_CONFIG_INCOMPATIBLE: u32 = 945u32;
pub const ERROR_ROUTER_STOPPED: u32 = 900u32;
pub const ERROR_SECCORE_INVALID_COMMAND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1058537472i32 as _);
pub const ERROR_SERVICE_IS_PAUSED: u32 = 928u32;
pub const ERROR_SMB_BAD_CLUSTER_DIALECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067646975i32 as _);
pub const ERROR_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067646976i32 as _);
pub const ERROR_SMB_NO_SIGNING_ALGORITHM_OVERLAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067646974i32 as _);
pub const ERROR_SPACES_ALLOCATION_SIZE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344818i32 as _);
pub const ERROR_SPACES_CACHE_FULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344794i32 as _);
pub const ERROR_SPACES_CORRUPT_METADATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344808i32 as _);
pub const ERROR_SPACES_DRIVE_LOST_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344801i32 as _);
pub const ERROR_SPACES_DRIVE_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344803i32 as _);
pub const ERROR_SPACES_DRIVE_OPERATIONAL_STATE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344814i32 as _);
pub const ERROR_SPACES_DRIVE_REDUNDANCY_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344826i32 as _);
pub const ERROR_SPACES_DRIVE_SECTOR_SIZE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344828i32 as _);
pub const ERROR_SPACES_DRIVE_SPLIT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344802i32 as _);
pub const ERROR_SPACES_DRT_FULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344807i32 as _);
pub const ERROR_SPACES_ENCLOSURE_AWARE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344817i32 as _);
pub const ERROR_SPACES_ENTRY_INCOMPLETE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344813i32 as _);
pub const ERROR_SPACES_ENTRY_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344812i32 as _);
pub const ERROR_SPACES_EXTENDED_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344820i32 as _);
pub const ERROR_SPACES_FAULT_DOMAIN_TYPE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344831i32 as _);
pub const ERROR_SPACES_FLUSH_METADATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344795i32 as _);
pub const ERROR_SPACES_INCONSISTENCY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344806i32 as _);
pub const ERROR_SPACES_INTERLEAVE_LENGTH_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344823i32 as _);
pub const ERROR_SPACES_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344830i32 as _);
pub const ERROR_SPACES_LOG_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344805i32 as _);
pub const ERROR_SPACES_MAP_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344810i32 as _);
pub const ERROR_SPACES_MARK_DIRTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344800i32 as _);
pub const ERROR_SPACES_NOT_ENOUGH_DRIVES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344821i32 as _);
pub const ERROR_SPACES_NO_REDUNDANCY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344804i32 as _);
pub const ERROR_SPACES_NUMBER_OF_COLUMNS_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344822i32 as _);
pub const ERROR_SPACES_NUMBER_OF_DATA_COPIES_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344825i32 as _);
pub const ERROR_SPACES_NUMBER_OF_GROUPS_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344815i32 as _);
pub const ERROR_SPACES_PARITY_LAYOUT_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344824i32 as _);
pub const ERROR_SPACES_POOL_WAS_DELETED: ::windows::core::HRESULT = ::windows::core::HRESULT(15138817i32 as _);
pub const ERROR_SPACES_PROVISIONING_TYPE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344819i32 as _);
pub const ERROR_SPACES_RESILIENCY_TYPE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344829i32 as _);
pub const ERROR_SPACES_UNSUPPORTED_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344809i32 as _);
pub const ERROR_SPACES_UPDATE_COLUMN_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344811i32 as _);
pub const ERROR_SPACES_WRITE_CACHE_SIZE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2132344816i32 as _);
pub const ERROR_SVHDX_ERROR_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067647232i32 as _);
pub const ERROR_SVHDX_ERROR_STORED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067712512i32 as _);
pub const ERROR_SVHDX_NO_INITIATOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067647221i32 as _);
pub const ERROR_SVHDX_RESERVATION_CONFLICT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067647225i32 as _);
pub const ERROR_SVHDX_UNIT_ATTENTION_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067647231i32 as _);
pub const ERROR_SVHDX_UNIT_ATTENTION_CAPACITY_DATA_CHANGED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067647230i32 as _);
pub const ERROR_SVHDX_UNIT_ATTENTION_OPERATING_DEFINITION_CHANGED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067647226i32 as _);
pub const ERROR_SVHDX_UNIT_ATTENTION_REGISTRATIONS_PREEMPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067647227i32 as _);
pub const ERROR_SVHDX_UNIT_ATTENTION_RESERVATIONS_PREEMPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067647229i32 as _);
pub const ERROR_SVHDX_UNIT_ATTENTION_RESERVATIONS_RELEASED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067647228i32 as _);
pub const ERROR_SVHDX_VERSION_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067647223i32 as _);
pub const ERROR_SVHDX_WRONG_FILE_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067647224i32 as _);
pub const ERROR_TIERING_ALREADY_PROCESSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138898426i32 as _);
pub const ERROR_TIERING_CANNOT_PIN_OBJECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138898425i32 as _);
pub const ERROR_TIERING_FILE_IS_NOT_PINNED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138898424i32 as _);
pub const ERROR_TIERING_INVALID_FILE_ID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138898428i32 as _);
pub const ERROR_TIERING_NOT_SUPPORTED_ON_VOLUME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138898431i32 as _);
pub const ERROR_TIERING_STORAGE_TIER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138898429i32 as _);
pub const ERROR_TIERING_VOLUME_DISMOUNT_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138898430i32 as _);
pub const ERROR_TIERING_WRONG_CLUSTER_NODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138898427i32 as _);
pub const ERROR_UNKNOWN_PROTOCOL_ID: u32 = 902u32;
pub const ERROR_UPDATE_IN_PROGRESS: u32 = 911u32;
pub const ERROR_USER_LIMIT: u32 = 937u32;
pub const ERROR_VHDSET_BACKING_STORAGE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067647220i32 as _);
pub const ERROR_VHD_SHARED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1067647222i32 as _);
pub const ERROR_VOLSNAP_ACTIVATION_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138963966i32 as _);
pub const ERROR_VOLSNAP_BOOTFILE_NOT_VALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138963967i32 as _);
pub const ERROR_VOLSNAP_NO_BYPASSIO_WITH_SNAPSHOT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138963965i32 as _);
pub const EVENT_E_ALL_SUBSCRIBERS_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220991i32 as _);
pub const EVENT_E_CANT_MODIFY_OR_DELETE_CONFIGURED_OBJECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220978i32 as _);
pub const EVENT_E_CANT_MODIFY_OR_DELETE_UNCONFIGURED_OBJECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220979i32 as _);
pub const EVENT_E_COMPLUS_NOT_INSTALLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220980i32 as _);
pub const EVENT_E_FIRST: i32 = -2147220992i32;
pub const EVENT_E_INTERNALERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220986i32 as _);
pub const EVENT_E_INTERNALEXCEPTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220987i32 as _);
pub const EVENT_E_INVALID_EVENT_CLASS_PARTITION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220977i32 as _);
pub const EVENT_E_INVALID_PER_USER_SID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220985i32 as _);
pub const EVENT_E_LAST: i32 = -2147220961i32;
pub const EVENT_E_MISSING_EVENTCLASS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220982i32 as _);
pub const EVENT_E_NOT_ALL_REMOVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220981i32 as _);
pub const EVENT_E_PER_USER_SID_NOT_LOGGED_ON: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220976i32 as _);
pub const EVENT_E_QUERYFIELD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220988i32 as _);
pub const EVENT_E_QUERYSYNTAX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220989i32 as _);
pub const EVENT_E_TOO_MANY_METHODS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220983i32 as _);
pub const EVENT_E_USER_EXCEPTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220984i32 as _);
pub const EVENT_S_FIRST: i32 = 262656i32;
pub const EVENT_S_LAST: i32 = 262687i32;
pub const EVENT_S_NOSUBSCRIBERS: ::windows::core::HRESULT = ::windows::core::HRESULT(262658i32 as _);
pub const EVENT_S_SOME_SUBSCRIBERS_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(262656i32 as _);
pub const E_ABORT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467260i32 as _);
pub const E_ACCESSDENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147024891i32 as _);
pub const E_APPLICATION_ACTIVATION_EXEC_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927141i32 as _);
pub const E_APPLICATION_ACTIVATION_TIMED_OUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927142i32 as _);
pub const E_APPLICATION_EXITING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483622i32 as _);
pub const E_APPLICATION_MANAGER_NOT_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927145i32 as _);
pub const E_APPLICATION_NOT_REGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927148i32 as _);
pub const E_APPLICATION_TEMPORARY_LICENSE_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927140i32 as _);
pub const E_APPLICATION_TRIAL_LICENSE_EXPIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927139i32 as _);
pub const E_APPLICATION_VIEW_EXITING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483621i32 as _);
pub const E_ASYNC_OPERATION_NOT_STARTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483623i32 as _);
pub const E_AUDIO_ENGINE_NODE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140798975i32 as _);
pub const E_BLUETOOTH_ATT_ATTRIBUTE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864502i32 as _);
pub const E_BLUETOOTH_ATT_ATTRIBUTE_NOT_LONG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864501i32 as _);
pub const E_BLUETOOTH_ATT_INSUFFICIENT_AUTHENTICATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864507i32 as _);
pub const E_BLUETOOTH_ATT_INSUFFICIENT_AUTHORIZATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864504i32 as _);
pub const E_BLUETOOTH_ATT_INSUFFICIENT_ENCRYPTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864497i32 as _);
pub const E_BLUETOOTH_ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864500i32 as _);
pub const E_BLUETOOTH_ATT_INSUFFICIENT_RESOURCES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864495i32 as _);
pub const E_BLUETOOTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864499i32 as _);
pub const E_BLUETOOTH_ATT_INVALID_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864511i32 as _);
pub const E_BLUETOOTH_ATT_INVALID_OFFSET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864505i32 as _);
pub const E_BLUETOOTH_ATT_INVALID_PDU: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864508i32 as _);
pub const E_BLUETOOTH_ATT_PREPARE_QUEUE_FULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864503i32 as _);
pub const E_BLUETOOTH_ATT_READ_NOT_PERMITTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864510i32 as _);
pub const E_BLUETOOTH_ATT_REQUEST_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864506i32 as _);
pub const E_BLUETOOTH_ATT_UNKNOWN_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140860416i32 as _);
pub const E_BLUETOOTH_ATT_UNLIKELY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864498i32 as _);
pub const E_BLUETOOTH_ATT_UNSUPPORTED_GROUP_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864496i32 as _);
pub const E_BLUETOOTH_ATT_WRITE_NOT_PERMITTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140864509i32 as _);
pub const E_BOUNDS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483637i32 as _);
pub const E_CHANGED_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483636i32 as _);
pub const E_ELEVATED_ACTIVATION_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927151i32 as _);
pub const E_FAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467259i32 as _);
pub const E_FULL_ADMIN_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927149i32 as _);
pub const E_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147024890i32 as _);
pub const E_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140798973i32 as _);
pub const E_HDAUDIO_EMPTY_CONNECTION_LIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140798974i32 as _);
pub const E_HDAUDIO_NO_LOGICAL_DEVICES_CREATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140798972i32 as _);
pub const E_HDAUDIO_NULL_LINKED_LIST_ENTRY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140798971i32 as _);
pub const E_ILLEGAL_DELEGATE_ASSIGNMENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483624i32 as _);
pub const E_ILLEGAL_METHOD_CALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483634i32 as _);
pub const E_ILLEGAL_STATE_CHANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483635i32 as _);
pub const E_INVALIDARG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147024809i32 as _);
pub const E_INVALID_PROTOCOL_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089418750i32 as _);
pub const E_INVALID_PROTOCOL_OPERATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089418751i32 as _);
pub const E_MBN_BAD_SIM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945342i32 as _);
pub const E_MBN_CONTEXT_NOT_ACTIVATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945343i32 as _);
pub const E_MBN_DATA_CLASS_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945341i32 as _);
pub const E_MBN_DEFAULT_PROFILE_EXIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945319i32 as _);
pub const E_MBN_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945326i32 as _);
pub const E_MBN_INVALID_ACCESS_STRING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945340i32 as _);
pub const E_MBN_INVALID_CACHE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945332i32 as _);
pub const E_MBN_INVALID_PROFILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945320i32 as _);
pub const E_MBN_MAX_ACTIVATED_CONTEXTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945339i32 as _);
pub const E_MBN_NOT_REGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945331i32 as _);
pub const E_MBN_PACKET_SVC_DETACHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945338i32 as _);
pub const E_MBN_PIN_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945327i32 as _);
pub const E_MBN_PIN_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945329i32 as _);
pub const E_MBN_PIN_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945328i32 as _);
pub const E_MBN_PROVIDERS_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945330i32 as _);
pub const E_MBN_PROVIDER_NOT_VISIBLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945337i32 as _);
pub const E_MBN_RADIO_POWER_OFF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945336i32 as _);
pub const E_MBN_SERVICE_NOT_ACTIVATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945335i32 as _);
pub const E_MBN_SIM_NOT_INSERTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945334i32 as _);
pub const E_MBN_SMS_ENCODING_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945312i32 as _);
pub const E_MBN_SMS_FILTER_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945311i32 as _);
pub const E_MBN_SMS_FORMAT_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945305i32 as _);
pub const E_MBN_SMS_INVALID_MEMORY_INDEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945310i32 as _);
pub const E_MBN_SMS_LANG_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945309i32 as _);
pub const E_MBN_SMS_MEMORY_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945308i32 as _);
pub const E_MBN_SMS_MEMORY_FULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945303i32 as _);
pub const E_MBN_SMS_NETWORK_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945307i32 as _);
pub const E_MBN_SMS_OPERATION_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945304i32 as _);
pub const E_MBN_SMS_UNKNOWN_SMSC_ADDRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945306i32 as _);
pub const E_MBN_VOICE_CALL_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2141945333i32 as _);
pub const E_MONITOR_RESOLUTION_TOO_LOW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927152i32 as _);
pub const E_MULTIPLE_EXTENSIONS_FOR_APPLICATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927147i32 as _);
pub const E_MULTIPLE_PACKAGES_FOR_FAMILY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927146i32 as _);
pub const E_NOINTERFACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467262i32 as _);
pub const E_NOTIMPL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467263i32 as _);
pub const E_OUTOFMEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147024882i32 as _);
pub const E_POINTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147467261i32 as _);
pub const E_PROTOCOL_EXTENSIONS_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089418749i32 as _);
pub const E_PROTOCOL_VERSION_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089418747i32 as _);
pub const E_SKYDRIVE_FILE_NOT_UPLOADED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927133i32 as _);
pub const E_SKYDRIVE_ROOT_TARGET_CANNOT_INDEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927134i32 as _);
pub const E_SKYDRIVE_ROOT_TARGET_FILE_SYSTEM_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927136i32 as _);
pub const E_SKYDRIVE_ROOT_TARGET_OVERLAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927135i32 as _);
pub const E_SKYDRIVE_ROOT_TARGET_VOLUME_ROOT_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927131i32 as _);
pub const E_SKYDRIVE_UPDATE_AVAILABILITY_FAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927132i32 as _);
pub const E_STRING_NOT_NULL_TERMINATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483625i32 as _);
pub const E_SUBPROTOCOL_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089418748i32 as _);
pub const E_SYNCENGINE_CLIENT_UPDATE_NEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013081594i32 as _);
pub const E_SYNCENGINE_FILE_IDENTIFIER_UNKNOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013085694i32 as _);
pub const E_SYNCENGINE_FILE_SIZE_EXCEEDS_REMAINING_QUOTA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013089790i32 as _);
pub const E_SYNCENGINE_FILE_SIZE_OVER_LIMIT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013089791i32 as _);
pub const E_SYNCENGINE_FILE_SYNC_PARTNER_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013089787i32 as _);
pub const E_SYNCENGINE_FOLDER_INACCESSIBLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013081599i32 as _);
pub const E_SYNCENGINE_FOLDER_IN_REDIRECTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013081589i32 as _);
pub const E_SYNCENGINE_FOLDER_ITEM_COUNT_LIMIT_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013089788i32 as _);
pub const E_SYNCENGINE_PATH_LENGTH_LIMIT_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013081596i32 as _);
pub const E_SYNCENGINE_PROXY_AUTHENTICATION_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013081593i32 as _);
pub const E_SYNCENGINE_REMOTE_PATH_LENGTH_LIMIT_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013081595i32 as _);
pub const E_SYNCENGINE_REQUEST_BLOCKED_BY_SERVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013085690i32 as _);
pub const E_SYNCENGINE_REQUEST_BLOCKED_DUE_TO_CLIENT_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013085689i32 as _);
pub const E_SYNCENGINE_SERVICE_AUTHENTICATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013085693i32 as _);
pub const E_SYNCENGINE_SERVICE_RETURNED_UNEXPECTED_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013085691i32 as _);
pub const E_SYNCENGINE_STORAGE_SERVICE_BLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013081590i32 as _);
pub const E_SYNCENGINE_STORAGE_SERVICE_PROVISIONING_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013081592i32 as _);
pub const E_SYNCENGINE_SYNC_PAUSED_BY_SERVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013089786i32 as _);
pub const E_SYNCENGINE_UNKNOWN_SERVICE_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013085692i32 as _);
pub const E_SYNCENGINE_UNSUPPORTED_FILE_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013089789i32 as _);
pub const E_SYNCENGINE_UNSUPPORTED_FOLDER_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013081598i32 as _);
pub const E_SYNCENGINE_UNSUPPORTED_MARKET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013081597i32 as _);
pub const E_SYNCENGINE_UNSUPPORTED_REPARSE_POINT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013081591i32 as _);
pub const E_UAC_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927150i32 as _);
pub const E_UNEXPECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418113i32 as _);
pub const FACILTIY_MUI_ERROR_CODE: u32 = 11u32;
pub type FARPROC = unsafe extern "system" fn() -> isize;
pub const FA_E_HOMEGROUP_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927198i32 as _);
pub const FA_E_MAX_PERSISTED_ITEMS_REACHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927200i32 as _);
pub const FDAEMON_E_CHANGEUPDATEFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215740i32 as _);
pub const FDAEMON_E_FATALERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215742i32 as _);
pub const FDAEMON_E_LOWRESOURCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215743i32 as _);
pub const FDAEMON_E_NOWORDLIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215737i32 as _);
pub const FDAEMON_E_PARTITIONDELETED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215741i32 as _);
pub const FDAEMON_E_TOOMANYFILTEREDBLOCKS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215736i32 as _);
pub const FDAEMON_E_WORDLISTCOMMITFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215738i32 as _);
pub const FDAEMON_W_EMPTYWORDLIST: ::windows::core::HRESULT = ::windows::core::HRESULT(267909i32 as _);
pub const FDAEMON_W_WORDLISTFULL: ::windows::core::HRESULT = ::windows::core::HRESULT(267904i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct FILETIME {
pub dwLowDateTime: u32,
pub dwHighDateTime: u32,
}
impl FILETIME {}
impl ::core::default::Default for FILETIME {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for FILETIME {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("FILETIME").field("dwLowDateTime", &self.dwLowDateTime).field("dwHighDateTime", &self.dwHighDateTime).finish()
}
}
impl ::core::cmp::PartialEq for FILETIME {
fn eq(&self, other: &Self) -> bool {
self.dwLowDateTime == other.dwLowDateTime && self.dwHighDateTime == other.dwHighDateTime
}
}
impl ::core::cmp::Eq for FILETIME {}
unsafe impl ::windows::core::Abi for FILETIME {
type Abi = Self;
}
pub const FILTER_E_ALREADY_OPEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215562i32 as _);
pub const FILTER_E_CONTENTINDEXCORRUPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473740i32 as _);
pub const FILTER_E_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215560i32 as _);
pub const FILTER_E_NOT_OPEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215559i32 as _);
pub const FILTER_E_NO_SUCH_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215557i32 as _);
pub const FILTER_E_OFFLINE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215555i32 as _);
pub const FILTER_E_PARTIALLY_FILTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215554i32 as _);
pub const FILTER_E_TOO_BIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215568i32 as _);
pub const FILTER_E_UNREACHABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215561i32 as _);
pub const FILTER_S_CONTENTSCAN_DELAYED: ::windows::core::HRESULT = ::windows::core::HRESULT(268083i32 as _);
pub const FILTER_S_DISK_FULL: ::windows::core::HRESULT = ::windows::core::HRESULT(268085i32 as _);
pub const FILTER_S_FULL_CONTENTSCAN_IMMEDIATE: ::windows::core::HRESULT = ::windows::core::HRESULT(268082i32 as _);
pub const FILTER_S_NO_PROPSETS: ::windows::core::HRESULT = ::windows::core::HRESULT(268090i32 as _);
pub const FILTER_S_NO_SECURITY_DESCRIPTOR: ::windows::core::HRESULT = ::windows::core::HRESULT(268092i32 as _);
pub const FILTER_S_PARTIAL_CONTENTSCAN_IMMEDIATE: ::windows::core::HRESULT = ::windows::core::HRESULT(268081i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct FLOAT128 {
pub LowPart: i64,
pub HighPart: i64,
}
impl FLOAT128 {}
impl ::core::default::Default for FLOAT128 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for FLOAT128 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("FLOAT128").field("LowPart", &self.LowPart).field("HighPart", &self.HighPart).finish()
}
}
impl ::core::cmp::PartialEq for FLOAT128 {
fn eq(&self, other: &Self) -> bool {
self.LowPart == other.LowPart && self.HighPart == other.HighPart
}
}
impl ::core::cmp::Eq for FLOAT128 {}
unsafe impl ::windows::core::Abi for FLOAT128 {
type Abi = Self;
}
pub const FRS_ERR_AUTHENTICATION: i32 = 8008i32;
pub const FRS_ERR_CHILD_TO_PARENT_COMM: i32 = 8011i32;
pub const FRS_ERR_INSUFFICIENT_PRIV: i32 = 8007i32;
pub const FRS_ERR_INTERNAL: i32 = 8005i32;
pub const FRS_ERR_INTERNAL_API: i32 = 8004i32;
pub const FRS_ERR_INVALID_API_SEQUENCE: i32 = 8001i32;
pub const FRS_ERR_INVALID_SERVICE_PARAMETER: i32 = 8017i32;
pub const FRS_ERR_PARENT_AUTHENTICATION: i32 = 8010i32;
pub const FRS_ERR_PARENT_INSUFFICIENT_PRIV: i32 = 8009i32;
pub const FRS_ERR_PARENT_TO_CHILD_COMM: i32 = 8012i32;
pub const FRS_ERR_SERVICE_COMM: i32 = 8006i32;
pub const FRS_ERR_STARTING_SERVICE: i32 = 8002i32;
pub const FRS_ERR_STOPPING_SERVICE: i32 = 8003i32;
pub const FRS_ERR_SYSVOL_DEMOTE: i32 = 8016i32;
pub const FRS_ERR_SYSVOL_IS_BUSY: i32 = 8015i32;
pub const FRS_ERR_SYSVOL_POPULATE: i32 = 8013i32;
pub const FRS_ERR_SYSVOL_POPULATE_TIMEOUT: i32 = 8014i32;
pub const FVE_E_AAD_ENDPOINT_BUSY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272159i32 as _);
pub const FVE_E_ACTION_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272375i32 as _);
pub const FVE_E_ADBACKUP_NOT_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272171i32 as _);
pub const FVE_E_AD_ATTR_NOT_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272370i32 as _);
pub const FVE_E_AD_BACKUP_REQUIRED_POLICY_NOT_SET_FIXED_DRIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272165i32 as _);
pub const FVE_E_AD_BACKUP_REQUIRED_POLICY_NOT_SET_OS_DRIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272166i32 as _);
pub const FVE_E_AD_BACKUP_REQUIRED_POLICY_NOT_SET_REMOVABLE_DRIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272164i32 as _);
pub const FVE_E_AD_GUID_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272369i32 as _);
pub const FVE_E_AD_INSUFFICIENT_BUFFER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272358i32 as _);
pub const FVE_E_AD_INVALID_DATASIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272372i32 as _);
pub const FVE_E_AD_INVALID_DATATYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272373i32 as _);
pub const FVE_E_AD_NO_VALUES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272371i32 as _);
pub const FVE_E_AD_SCHEMA_NOT_INSTALLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272374i32 as _);
pub const FVE_E_AUTH_INVALID_APPLICATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272316i32 as _);
pub const FVE_E_AUTH_INVALID_CONFIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272315i32 as _);
pub const FVE_E_AUTOUNLOCK_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272343i32 as _);
pub const FVE_E_BAD_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272362i32 as _);
pub const FVE_E_BAD_INFORMATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272368i32 as _);
pub const FVE_E_BAD_PARTITION_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272364i32 as _);
pub const FVE_E_BCD_APPLICATIONS_PATH_INCORRECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272302i32 as _);
pub const FVE_E_BOOTABLE_CDDVD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272336i32 as _);
pub const FVE_E_BUFFER_TOO_LARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272177i32 as _);
pub const FVE_E_CANNOT_ENCRYPT_NO_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272338i32 as _);
pub const FVE_E_CANNOT_SET_FVEK_ENCRYPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272339i32 as _);
pub const FVE_E_CANT_LOCK_AUTOUNLOCK_ENABLED_VOLUME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272233i32 as _);
pub const FVE_E_CLUSTERING_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272354i32 as _);
pub const FVE_E_CONV_READ: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272357i32 as _);
pub const FVE_E_CONV_RECOVERY_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272248i32 as _);
pub const FVE_E_CONV_WRITE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272356i32 as _);
pub const FVE_E_DEBUGGER_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272305i32 as _);
pub const FVE_E_DEVICELOCKOUT_COUNTER_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272178i32 as _);
pub const FVE_E_DEVICE_LOCKOUT_COUNTER_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272179i32 as _);
pub const FVE_E_DEVICE_NOT_JOINED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272160i32 as _);
pub const FVE_E_DE_DEVICE_LOCKEDOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272182i32 as _);
pub const FVE_E_DE_FIXED_DATA_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272187i32 as _);
pub const FVE_E_DE_HARDWARE_NOT_COMPLIANT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272186i32 as _);
pub const FVE_E_DE_OS_VOLUME_NOT_PROTECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272183i32 as _);
pub const FVE_E_DE_PREVENTED_FOR_OS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272175i32 as _);
pub const FVE_E_DE_PROTECTION_NOT_YET_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272181i32 as _);
pub const FVE_E_DE_PROTECTION_SUSPENDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272184i32 as _);
pub const FVE_E_DE_VOLUME_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272173i32 as _);
pub const FVE_E_DE_VOLUME_OPTED_OUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272174i32 as _);
pub const FVE_E_DE_WINRE_NOT_CONFIGURED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272185i32 as _);
pub const FVE_E_DRY_RUN_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272307i32 as _);
pub const FVE_E_DV_NOT_ALLOWED_BY_GP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272271i32 as _);
pub const FVE_E_DV_NOT_SUPPORTED_ON_FS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272272i32 as _);
pub const FVE_E_EDRIVE_BAND_ENUMERATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272157i32 as _);
pub const FVE_E_EDRIVE_BAND_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272208i32 as _);
pub const FVE_E_EDRIVE_DISALLOWED_BY_GP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272207i32 as _);
pub const FVE_E_EDRIVE_DRY_RUN_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272196i32 as _);
pub const FVE_E_EDRIVE_DV_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272204i32 as _);
pub const FVE_E_EDRIVE_INCOMPATIBLE_FIRMWARE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272193i32 as _);
pub const FVE_E_EDRIVE_INCOMPATIBLE_VOLUME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272206i32 as _);
pub const FVE_E_EDRIVE_NO_FAILOVER_TO_SW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272209i32 as _);
pub const FVE_E_EFI_ONLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272228i32 as _);
pub const FVE_E_ENH_PIN_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272231i32 as _);
pub const FVE_E_EOW_NOT_SUPPORTED_IN_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272172i32 as _);
pub const FVE_E_EXECUTE_REQUEST_SENT_TOO_SOON: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272162i32 as _);
pub const FVE_E_FAILED_AUTHENTICATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272345i32 as _);
pub const FVE_E_FAILED_SECTOR_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272346i32 as _);
pub const FVE_E_FAILED_WRONG_FS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272365i32 as _);
pub const FVE_E_FIPS_DISABLE_PROTECTION_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272314i32 as _);
pub const FVE_E_FIPS_HASH_KDF_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272232i32 as _);
pub const FVE_E_FIPS_PREVENTS_EXTERNAL_KEY_EXPORT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272328i32 as _);
pub const FVE_E_FIPS_PREVENTS_PASSPHRASE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272276i32 as _);
pub const FVE_E_FIPS_PREVENTS_RECOVERY_PASSWORD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272329i32 as _);
pub const FVE_E_FIPS_RNG_CHECK_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272330i32 as _);
pub const FVE_E_FIRMWARE_TYPE_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272312i32 as _);
pub const FVE_E_FOREIGN_VOLUME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272349i32 as _);
pub const FVE_E_FS_MOUNTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272309i32 as _);
pub const FVE_E_FS_NOT_EXTENDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272313i32 as _);
pub const FVE_E_FULL_ENCRYPTION_NOT_ALLOWED_ON_TP_STORAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272219i32 as _);
pub const FVE_E_HIDDEN_VOLUME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272298i32 as _);
pub const FVE_E_INVALID_BITLOCKER_OID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272274i32 as _);
pub const FVE_E_INVALID_DATUM_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272229i32 as _);
pub const FVE_E_INVALID_KEY_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272332i32 as _);
pub const FVE_E_INVALID_NBP_CERT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272158i32 as _);
pub const FVE_E_INVALID_NKP_CERT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272225i32 as _);
pub const FVE_E_INVALID_PASSWORD_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272331i32 as _);
pub const FVE_E_INVALID_PIN_CHARS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272230i32 as _);
pub const FVE_E_INVALID_PIN_CHARS_DETAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272180i32 as _);
pub const FVE_E_INVALID_PROTECTOR_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272326i32 as _);
pub const FVE_E_INVALID_STARTUP_OPTIONS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272293i32 as _);
pub const FVE_E_KEYFILE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272323i32 as _);
pub const FVE_E_KEYFILE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272324i32 as _);
pub const FVE_E_KEYFILE_NO_VMK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272322i32 as _);
pub const FVE_E_KEY_LENGTH_NOT_SUPPORTED_BY_EDRIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272217i32 as _);
pub const FVE_E_KEY_PROTECTOR_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272279i32 as _);
pub const FVE_E_KEY_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272355i32 as _);
pub const FVE_E_KEY_ROTATION_NOT_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272161i32 as _);
pub const FVE_E_KEY_ROTATION_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272163i32 as _);
pub const FVE_E_LIVEID_ACCOUNT_BLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272189i32 as _);
pub const FVE_E_LIVEID_ACCOUNT_SUSPENDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272190i32 as _);
pub const FVE_E_LOCKED_VOLUME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272384i32 as _);
pub const FVE_E_MOR_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272299i32 as _);
pub const FVE_E_MULTIPLE_NKP_CERTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272227i32 as _);
pub const FVE_E_NON_BITLOCKER_KU: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272237i32 as _);
pub const FVE_E_NON_BITLOCKER_OID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272251i32 as _);
pub const FVE_E_NOT_ACTIVATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272376i32 as _);
pub const FVE_E_NOT_ALLOWED_IN_SAFE_MODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272320i32 as _);
pub const FVE_E_NOT_ALLOWED_IN_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272301i32 as _);
pub const FVE_E_NOT_ALLOWED_ON_CLUSTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272210i32 as _);
pub const FVE_E_NOT_ALLOWED_ON_CSV_STACK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272211i32 as _);
pub const FVE_E_NOT_ALLOWED_TO_UPGRADE_WHILE_CONVERTING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272205i32 as _);
pub const FVE_E_NOT_DATA_VOLUME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272359i32 as _);
pub const FVE_E_NOT_DECRYPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272327i32 as _);
pub const FVE_E_NOT_DE_VOLUME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272169i32 as _);
pub const FVE_E_NOT_ENCRYPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272383i32 as _);
pub const FVE_E_NOT_ON_STACK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272310i32 as _);
pub const FVE_E_NOT_OS_VOLUME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272344i32 as _);
pub const FVE_E_NOT_PROVISIONED_ON_ALL_VOLUMES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272188i32 as _);
pub const FVE_E_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272363i32 as _);
pub const FVE_E_NO_AUTOUNLOCK_MASTER_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272300i32 as _);
pub const FVE_E_NO_BOOTMGR_METRIC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272379i32 as _);
pub const FVE_E_NO_BOOTSECTOR_METRIC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272380i32 as _);
pub const FVE_E_NO_EXISTING_PASSPHRASE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272216i32 as _);
pub const FVE_E_NO_EXISTING_PIN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272224i32 as _);
pub const FVE_E_NO_FEATURE_LICENSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272294i32 as _);
pub const FVE_E_NO_LICENSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272311i32 as _);
pub const FVE_E_NO_MBR_METRIC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272381i32 as _);
pub const FVE_E_NO_PASSPHRASE_WITH_TPM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272213i32 as _);
pub const FVE_E_NO_PREBOOT_KEYBOARD_DETECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272203i32 as _);
pub const FVE_E_NO_PREBOOT_KEYBOARD_OR_WINRE_DETECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272202i32 as _);
pub const FVE_E_NO_PROTECTORS_TO_TEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272325i32 as _);
pub const FVE_E_NO_SUCH_CAPABILITY_ON_TARGET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272176i32 as _);
pub const FVE_E_NO_TPM_BIOS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272382i32 as _);
pub const FVE_E_NO_TPM_WITH_PASSPHRASE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272212i32 as _);
pub const FVE_E_OPERATION_NOT_SUPPORTED_ON_VISTA_VOLUME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272234i32 as _);
pub const FVE_E_OSV_KSR_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272167i32 as _);
pub const FVE_E_OS_NOT_PROTECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272352i32 as _);
pub const FVE_E_OS_VOLUME_PASSPHRASE_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272275i32 as _);
pub const FVE_E_OVERLAPPED_UPDATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272348i32 as _);
pub const FVE_E_PASSPHRASE_PROTECTOR_CHANGE_BY_STD_USER_DISALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272191i32 as _);
pub const FVE_E_PASSPHRASE_TOO_LONG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272214i32 as _);
pub const FVE_E_PIN_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272317i32 as _);
pub const FVE_E_PIN_PROTECTOR_CHANGE_BY_STD_USER_DISALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272222i32 as _);
pub const FVE_E_POLICY_CONFLICT_FDV_RK_OFF_AUK_ON: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272253i32 as _);
pub const FVE_E_POLICY_CONFLICT_FDV_RP_OFF_ADB_ON: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272239i32 as _);
pub const FVE_E_POLICY_CONFLICT_OSV_RP_OFF_ADB_ON: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272240i32 as _);
pub const FVE_E_POLICY_CONFLICT_RDV_RK_OFF_AUK_ON: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272252i32 as _);
pub const FVE_E_POLICY_CONFLICT_RDV_RP_OFF_ADB_ON: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272238i32 as _);
pub const FVE_E_POLICY_CONFLICT_RO_AND_STARTUP_KEY_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272249i32 as _);
pub const FVE_E_POLICY_INVALID_ENHANCED_BCD_SETTINGS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272194i32 as _);
pub const FVE_E_POLICY_INVALID_PASSPHRASE_LENGTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272256i32 as _);
pub const FVE_E_POLICY_INVALID_PIN_LENGTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272280i32 as _);
pub const FVE_E_POLICY_ON_RDV_EXCLUSION_LIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272156i32 as _);
pub const FVE_E_POLICY_PASSPHRASE_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272278i32 as _);
pub const FVE_E_POLICY_PASSPHRASE_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272277i32 as _);
pub const FVE_E_POLICY_PASSPHRASE_REQUIRES_ASCII: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272220i32 as _);
pub const FVE_E_POLICY_PASSPHRASE_TOO_SIMPLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272255i32 as _);
pub const FVE_E_POLICY_PASSWORD_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272340i32 as _);
pub const FVE_E_POLICY_PROHIBITS_SELFSIGNED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272250i32 as _);
pub const FVE_E_POLICY_RECOVERY_KEY_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272290i32 as _);
pub const FVE_E_POLICY_RECOVERY_KEY_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272289i32 as _);
pub const FVE_E_POLICY_RECOVERY_PASSWORD_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272292i32 as _);
pub const FVE_E_POLICY_RECOVERY_PASSWORD_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272291i32 as _);
pub const FVE_E_POLICY_REQUIRES_RECOVERY_PASSWORD_ON_TOUCH_DEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272200i32 as _);
pub const FVE_E_POLICY_REQUIRES_STARTUP_PIN_ON_TOUCH_DEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272201i32 as _);
pub const FVE_E_POLICY_STARTUP_KEY_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272286i32 as _);
pub const FVE_E_POLICY_STARTUP_KEY_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272285i32 as _);
pub const FVE_E_POLICY_STARTUP_PIN_KEY_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272284i32 as _);
pub const FVE_E_POLICY_STARTUP_PIN_KEY_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272283i32 as _);
pub const FVE_E_POLICY_STARTUP_PIN_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272288i32 as _);
pub const FVE_E_POLICY_STARTUP_PIN_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272287i32 as _);
pub const FVE_E_POLICY_STARTUP_TPM_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272282i32 as _);
pub const FVE_E_POLICY_STARTUP_TPM_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272281i32 as _);
pub const FVE_E_POLICY_USER_CERTIFICATE_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272270i32 as _);
pub const FVE_E_POLICY_USER_CERTIFICATE_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272269i32 as _);
pub const FVE_E_POLICY_USER_CERT_MUST_BE_HW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272268i32 as _);
pub const FVE_E_POLICY_USER_CONFIGURE_FDV_AUTOUNLOCK_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272267i32 as _);
pub const FVE_E_POLICY_USER_CONFIGURE_RDV_AUTOUNLOCK_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272266i32 as _);
pub const FVE_E_POLICY_USER_CONFIGURE_RDV_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272265i32 as _);
pub const FVE_E_POLICY_USER_DISABLE_RDV_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272263i32 as _);
pub const FVE_E_POLICY_USER_ENABLE_RDV_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272264i32 as _);
pub const FVE_E_PREDICTED_TPM_PROTECTOR_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272155i32 as _);
pub const FVE_E_PRIVATEKEY_AUTH_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272236i32 as _);
pub const FVE_E_PROTECTION_CANNOT_BE_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272168i32 as _);
pub const FVE_E_PROTECTION_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272351i32 as _);
pub const FVE_E_PROTECTOR_CHANGE_MAX_PASSPHRASE_CHANGE_ATTEMPTS_REACHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272192i32 as _);
pub const FVE_E_PROTECTOR_CHANGE_MAX_PIN_CHANGE_ATTEMPTS_REACHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272221i32 as _);
pub const FVE_E_PROTECTOR_CHANGE_PASSPHRASE_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272215i32 as _);
pub const FVE_E_PROTECTOR_CHANGE_PIN_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272223i32 as _);
pub const FVE_E_PROTECTOR_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272335i32 as _);
pub const FVE_E_PROTECTOR_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272333i32 as _);
pub const FVE_E_PUBKEY_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272296i32 as _);
pub const FVE_E_RAW_ACCESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272304i32 as _);
pub const FVE_E_RAW_BLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272303i32 as _);
pub const FVE_E_REBOOT_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272306i32 as _);
pub const FVE_E_RECOVERY_KEY_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272350i32 as _);
pub const FVE_E_RECOVERY_PARTITION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272254i32 as _);
pub const FVE_E_RELATIVE_PATH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272334i32 as _);
pub const FVE_E_REMOVAL_OF_DRA_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272235i32 as _);
pub const FVE_E_REMOVAL_OF_NKP_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272226i32 as _);
pub const FVE_E_SECUREBOOT_CONFIGURATION_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272197i32 as _);
pub const FVE_E_SECUREBOOT_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272198i32 as _);
pub const FVE_E_SECURE_KEY_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272377i32 as _);
pub const FVE_E_SETUP_TPM_CALLBACK_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272154i32 as _);
pub const FVE_E_SHADOW_COPY_PRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272195i32 as _);
pub const FVE_E_SYSTEM_VOLUME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272366i32 as _);
pub const FVE_E_TOKEN_NOT_IMPERSONATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272308i32 as _);
pub const FVE_E_TOO_SMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272367i32 as _);
pub const FVE_E_TPM_CONTEXT_SETUP_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272153i32 as _);
pub const FVE_E_TPM_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272321i32 as _);
pub const FVE_E_TPM_INVALID_PCR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272319i32 as _);
pub const FVE_E_TPM_NOT_OWNED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272360i32 as _);
pub const FVE_E_TPM_NO_VMK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272318i32 as _);
pub const FVE_E_TPM_SRK_AUTH_NOT_ZERO: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272347i32 as _);
pub const FVE_E_TRANSIENT_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272297i32 as _);
pub const FVE_E_VIRTUALIZED_SPACE_TOO_BIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272247i32 as _);
pub const FVE_E_VOLUME_BOUND_ALREADY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272353i32 as _);
pub const FVE_E_VOLUME_EXTEND_PREVENTS_EOW_DECRYPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272170i32 as _);
pub const FVE_E_VOLUME_HANDLE_OPEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272295i32 as _);
pub const FVE_E_VOLUME_NOT_BOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272361i32 as _);
pub const FVE_E_VOLUME_TOO_SMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272273i32 as _);
pub const FVE_E_WIPE_CANCEL_NOT_APPLICABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272199i32 as _);
pub const FVE_E_WIPE_NOT_ALLOWED_ON_TP_STORAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272218i32 as _);
pub const FVE_E_WRONG_BOOTMGR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272378i32 as _);
pub const FVE_E_WRONG_BOOTSECTOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272342i32 as _);
pub const FVE_E_WRONG_SYSTEM_FS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144272341i32 as _);
pub const FWP_E_ACTION_INCOMPATIBLE_WITH_LAYER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206804i32 as _);
pub const FWP_E_ACTION_INCOMPATIBLE_WITH_SUBLAYER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206803i32 as _);
pub const FWP_E_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206839i32 as _);
pub const FWP_E_BUILTIN_OBJECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206825i32 as _);
pub const FWP_E_CALLOUT_NOTIFICATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206793i32 as _);
pub const FWP_E_CALLOUT_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206847i32 as _);
pub const FWP_E_CONDITION_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206846i32 as _);
pub const FWP_E_CONNECTIONS_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206783i32 as _);
pub const FWP_E_CONTEXT_INCOMPATIBLE_WITH_CALLOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206801i32 as _);
pub const FWP_E_CONTEXT_INCOMPATIBLE_WITH_LAYER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206802i32 as _);
pub const FWP_E_DROP_NOICMP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206588i32 as _);
pub const FWP_E_DUPLICATE_AUTH_METHOD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206788i32 as _);
pub const FWP_E_DUPLICATE_CONDITION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206806i32 as _);
pub const FWP_E_DUPLICATE_KEYMOD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206805i32 as _);
pub const FWP_E_DYNAMIC_SESSION_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206837i32 as _);
pub const FWP_E_EM_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206798i32 as _);
pub const FWP_E_FILTER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206845i32 as _);
pub const FWP_E_IKEEXT_NOT_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206780i32 as _);
pub const FWP_E_INCOMPATIBLE_AUTH_METHOD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206800i32 as _);
pub const FWP_E_INCOMPATIBLE_CIPHER_TRANSFORM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206790i32 as _);
pub const FWP_E_INCOMPATIBLE_DH_GROUP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206799i32 as _);
pub const FWP_E_INCOMPATIBLE_LAYER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206828i32 as _);
pub const FWP_E_INCOMPATIBLE_SA_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206821i32 as _);
pub const FWP_E_INCOMPATIBLE_TXN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206831i32 as _);
pub const FWP_E_INVALID_ACTION_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206812i32 as _);
pub const FWP_E_INVALID_AUTH_TRANSFORM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206792i32 as _);
pub const FWP_E_INVALID_CIPHER_TRANSFORM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206791i32 as _);
pub const FWP_E_INVALID_DNS_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206782i32 as _);
pub const FWP_E_INVALID_ENUMERATOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206819i32 as _);
pub const FWP_E_INVALID_FLAGS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206818i32 as _);
pub const FWP_E_INVALID_INTERVAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206815i32 as _);
pub const FWP_E_INVALID_NET_MASK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206817i32 as _);
pub const FWP_E_INVALID_PARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206795i32 as _);
pub const FWP_E_INVALID_RANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206816i32 as _);
pub const FWP_E_INVALID_TRANSFORM_COMBINATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206789i32 as _);
pub const FWP_E_INVALID_TUNNEL_ENDPOINT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206787i32 as _);
pub const FWP_E_INVALID_WEIGHT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206811i32 as _);
pub const FWP_E_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206838i32 as _);
pub const FWP_E_KEY_DICTATION_INVALID_KEYING_MATERIAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206784i32 as _);
pub const FWP_E_KEY_DICTATOR_ALREADY_REGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206785i32 as _);
pub const FWP_E_KM_CLIENTS_ONLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206827i32 as _);
pub const FWP_E_L2_DRIVER_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206786i32 as _);
pub const FWP_E_LAYER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206844i32 as _);
pub const FWP_E_LIFETIME_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206826i32 as _);
pub const FWP_E_MATCH_TYPE_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206810i32 as _);
pub const FWP_E_NET_EVENTS_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206829i32 as _);
pub const FWP_E_NEVER_MATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206797i32 as _);
pub const FWP_E_NOTIFICATION_DROPPED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206823i32 as _);
pub const FWP_E_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206840i32 as _);
pub const FWP_E_NO_TXN_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206835i32 as _);
pub const FWP_E_NULL_DISPLAY_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206813i32 as _);
pub const FWP_E_NULL_POINTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206820i32 as _);
pub const FWP_E_OUT_OF_BOUNDS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206808i32 as _);
pub const FWP_E_PROVIDER_CONTEXT_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206796i32 as _);
pub const FWP_E_PROVIDER_CONTEXT_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206842i32 as _);
pub const FWP_E_PROVIDER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206843i32 as _);
pub const FWP_E_RESERVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206807i32 as _);
pub const FWP_E_SESSION_ABORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206832i32 as _);
pub const FWP_E_STILL_ON: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206781i32 as _);
pub const FWP_E_SUBLAYER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206841i32 as _);
pub const FWP_E_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206830i32 as _);
pub const FWP_E_TOO_MANY_CALLOUTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206824i32 as _);
pub const FWP_E_TOO_MANY_SUBLAYERS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206794i32 as _);
pub const FWP_E_TRAFFIC_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206822i32 as _);
pub const FWP_E_TXN_ABORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206833i32 as _);
pub const FWP_E_TXN_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206834i32 as _);
pub const FWP_E_TYPE_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206809i32 as _);
pub const FWP_E_WRONG_SESSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206836i32 as _);
pub const FWP_E_ZERO_LENGTH_ARRAY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144206814i32 as _);
pub const GCN_E_DEFAULTNAMESPACE_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616983i32 as _);
pub const GCN_E_MODULE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616991i32 as _);
pub const GCN_E_NETADAPTER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616986i32 as _);
pub const GCN_E_NETADAPTER_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616987i32 as _);
pub const GCN_E_NETCOMPARTMENT_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616985i32 as _);
pub const GCN_E_NETINTERFACE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616984i32 as _);
pub const GCN_E_NO_REQUEST_HANDLERS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616990i32 as _);
pub const GCN_E_REQUEST_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616989i32 as _);
pub const GCN_E_RUNTIMEKEYS_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616988i32 as _);
#[inline]
pub unsafe fn GetHandleInformation<'a, Param0: ::windows::core::IntoParam<'a, HANDLE>>(hobject: Param0, lpdwflags: *mut u32) -> BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetHandleInformation(hobject: HANDLE, lpdwflags: *mut u32) -> BOOL;
}
::core::mem::transmute(GetHandleInformation(hobject.into_param().abi(), ::core::mem::transmute(lpdwflags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn GetLastError() -> WIN32_ERROR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetLastError() -> WIN32_ERROR;
}
::core::mem::transmute(GetLastError())
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: default :: Default, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct HANDLE(pub isize);
unsafe impl ::windows::core::Handle for HANDLE {
fn is_invalid(&self) -> bool {
self.0 == 0 || self.0 == -1
}
fn ok(self) -> ::windows::core::Result<Self> {
if self.is_invalid() {
Err(::windows::core::Error::from_win32())
} else {
Ok(self)
}
}
}
unsafe impl ::windows::core::Abi for HANDLE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct HANDLE_FLAGS(pub u32);
pub const HANDLE_FLAG_INHERIT: HANDLE_FLAGS = HANDLE_FLAGS(1u32);
pub const HANDLE_FLAG_PROTECT_FROM_CLOSE: HANDLE_FLAGS = HANDLE_FLAGS(2u32);
impl ::core::convert::From<u32> for HANDLE_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for HANDLE_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for HANDLE_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for HANDLE_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for HANDLE_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for HANDLE_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for HANDLE_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct HANDLE_PTR(pub usize);
impl ::core::default::Default for HANDLE_PTR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
unsafe impl ::windows::core::Handle for HANDLE_PTR {}
unsafe impl ::windows::core::Abi for HANDLE_PTR {
type Abi = Self;
}
pub const HCN_E_ADAPTER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617018i32 as _);
pub const HCN_E_ADDR_INVALID_OR_RESERVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616977i32 as _);
pub const HCN_E_DEGRADED_OPERATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617001i32 as _);
pub const HCN_E_ENDPOINT_ALREADY_ATTACHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617004i32 as _);
pub const HCN_E_ENDPOINT_NAMESPACE_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616981i32 as _);
pub const HCN_E_ENDPOINT_NOT_ATTACHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616972i32 as _);
pub const HCN_E_ENDPOINT_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617022i32 as _);
pub const HCN_E_ENDPOINT_NOT_LOCAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616971i32 as _);
pub const HCN_E_ENDPOINT_SHARING_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616995i32 as _);
pub const HCN_E_ENTITY_HAS_REFERENCES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616980i32 as _);
pub const HCN_E_GUID_CONVERSION_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616999i32 as _);
pub const HCN_E_ICS_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616982i32 as _);
pub const HCN_E_INVALID_ENDPOINT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617012i32 as _);
pub const HCN_E_INVALID_INTERNAL_PORT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616979i32 as _);
pub const HCN_E_INVALID_IP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616994i32 as _);
pub const HCN_E_INVALID_IP_SUBNET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616973i32 as _);
pub const HCN_E_INVALID_JSON: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616997i32 as _);
pub const HCN_E_INVALID_JSON_REFERENCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616996i32 as _);
pub const HCN_E_INVALID_NETWORK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617014i32 as _);
pub const HCN_E_INVALID_NETWORK_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617013i32 as _);
pub const HCN_E_INVALID_POLICY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617011i32 as _);
pub const HCN_E_INVALID_POLICY_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617010i32 as _);
pub const HCN_E_INVALID_PREFIX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616976i32 as _);
pub const HCN_E_INVALID_REMOTE_ENDPOINT_OPERATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617009i32 as _);
pub const HCN_E_INVALID_SUBNET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616974i32 as _);
pub const HCN_E_LAYER_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617007i32 as _);
pub const HCN_E_LAYER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617021i32 as _);
pub const HCN_E_MANAGER_STOPPED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616992i32 as _);
pub const HCN_E_MAPPING_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617002i32 as _);
pub const HCN_E_NAMESPACE_ATTACH_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616978i32 as _);
pub const HCN_E_NETWORK_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617008i32 as _);
pub const HCN_E_NETWORK_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617023i32 as _);
pub const HCN_E_OBJECT_USED_AFTER_UNLOAD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616975i32 as _);
pub const HCN_E_POLICY_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617006i32 as _);
pub const HCN_E_POLICY_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617016i32 as _);
pub const HCN_E_PORT_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617005i32 as _);
pub const HCN_E_PORT_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617017i32 as _);
pub const HCN_E_REGKEY_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616998i32 as _);
pub const HCN_E_REQUEST_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617003i32 as _);
pub const HCN_E_SHARED_SWITCH_MODIFICATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617000i32 as _);
pub const HCN_E_SUBNET_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617019i32 as _);
pub const HCN_E_SWITCH_EXTENSION_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616993i32 as _);
pub const HCN_E_SWITCH_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617020i32 as _);
pub const HCN_E_VFP_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616969i32 as _);
pub const HCN_E_VFP_PORTSETTING_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143617015i32 as _);
pub const HCN_INTERFACEPARAMETERS_ALREADY_APPLIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143616970i32 as _);
pub const HCS_E_ACCESS_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878885i32 as _);
pub const HCS_E_CONNECTION_CLOSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878902i32 as _);
pub const HCS_E_CONNECTION_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878903i32 as _);
pub const HCS_E_CONNECT_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878904i32 as _);
pub const HCS_E_GUEST_CRITICAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878884i32 as _);
pub const HCS_E_HYPERV_NOT_INSTALLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878910i32 as _);
pub const HCS_E_IMAGE_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878911i32 as _);
pub const HCS_E_INVALID_JSON: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878899i32 as _);
pub const HCS_E_INVALID_LAYER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878894i32 as _);
pub const HCS_E_INVALID_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878907i32 as _);
pub const HCS_E_OPERATION_ALREADY_STARTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878890i32 as _);
pub const HCS_E_OPERATION_NOT_STARTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878891i32 as _);
pub const HCS_E_OPERATION_PENDING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878889i32 as _);
pub const HCS_E_OPERATION_RESULT_ALLOCATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878886i32 as _);
pub const HCS_E_OPERATION_SYSTEM_CALLBACK_ALREADY_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878887i32 as _);
pub const HCS_E_OPERATION_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878888i32 as _);
pub const HCS_E_PROCESS_ALREADY_STOPPED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878881i32 as _);
pub const HCS_E_PROCESS_INFO_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878883i32 as _);
pub const HCS_E_PROTOCOL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878895i32 as _);
pub const HCS_E_SERVICE_DISCONNECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878882i32 as _);
pub const HCS_E_SERVICE_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878892i32 as _);
pub const HCS_E_SYSTEM_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878897i32 as _);
pub const HCS_E_SYSTEM_ALREADY_STOPPED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878896i32 as _);
pub const HCS_E_SYSTEM_NOT_CONFIGURED_FOR_OPERATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878880i32 as _);
pub const HCS_E_SYSTEM_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878898i32 as _);
pub const HCS_E_TERMINATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878905i32 as _);
pub const HCS_E_TERMINATED_DURING_START: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878912i32 as _);
pub const HCS_E_UNEXPECTED_EXIT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878906i32 as _);
pub const HCS_E_UNKNOWN_MESSAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878901i32 as _);
pub const HCS_E_UNSUPPORTED_PROTOCOL_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878900i32 as _);
pub const HCS_E_WINDOWS_INSIDER_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878893i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct HINSTANCE(pub isize);
impl ::core::default::Default for HINSTANCE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
unsafe impl ::windows::core::Handle for HINSTANCE {}
unsafe impl ::windows::core::Abi for HINSTANCE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct HLSURF__ {
pub unused: i32,
}
impl HLSURF__ {}
impl ::core::default::Default for HLSURF__ {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for HLSURF__ {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("HLSURF__").field("unused", &self.unused).finish()
}
}
impl ::core::cmp::PartialEq for HLSURF__ {
fn eq(&self, other: &Self) -> bool {
self.unused == other.unused
}
}
impl ::core::cmp::Eq for HLSURF__ {}
unsafe impl ::windows::core::Abi for HLSURF__ {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct HRSRC(pub isize);
impl ::core::default::Default for HRSRC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
unsafe impl ::windows::core::Handle for HRSRC {}
unsafe impl ::windows::core::Abi for HRSRC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct HSPRITE__ {
pub unused: i32,
}
impl HSPRITE__ {}
impl ::core::default::Default for HSPRITE__ {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for HSPRITE__ {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("HSPRITE__").field("unused", &self.unused).finish()
}
}
impl ::core::cmp::PartialEq for HSPRITE__ {
fn eq(&self, other: &Self) -> bool {
self.unused == other.unused
}
}
impl ::core::cmp::Eq for HSPRITE__ {}
unsafe impl ::windows::core::Abi for HSPRITE__ {
type Abi = Self;
}
pub const HSP_BASE_ERROR_MASK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128019200i32 as _);
pub const HSP_BASE_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018945i32 as _);
pub const HSP_BS_ERROR_MASK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128080896i32 as _);
pub const HSP_BS_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128080641i32 as _);
pub const HSP_DRV_ERROR_MASK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128019456i32 as _);
pub const HSP_DRV_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128019201i32 as _);
pub const HSP_E_ERROR_MASK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128084992i32 as _);
pub const HSP_E_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128080897i32 as _);
pub const HSP_KSP_ALGORITHM_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018935i32 as _);
pub const HSP_KSP_BUFFER_TOO_SMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018939i32 as _);
pub const HSP_KSP_DEVICE_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018943i32 as _);
pub const HSP_KSP_ERROR_MASK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018944i32 as _);
pub const HSP_KSP_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018689i32 as _);
pub const HSP_KSP_INVALID_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018937i32 as _);
pub const HSP_KSP_INVALID_FLAGS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018936i32 as _);
pub const HSP_KSP_INVALID_KEY_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018941i32 as _);
pub const HSP_KSP_INVALID_KEY_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018932i32 as _);
pub const HSP_KSP_INVALID_PARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018940i32 as _);
pub const HSP_KSP_INVALID_PROVIDER_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018942i32 as _);
pub const HSP_KSP_KEY_ALREADY_FINALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018934i32 as _);
pub const HSP_KSP_KEY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018923i32 as _);
pub const HSP_KSP_KEY_LOAD_FAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018921i32 as _);
pub const HSP_KSP_KEY_MISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018922i32 as _);
pub const HSP_KSP_KEY_NOT_FINALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018933i32 as _);
pub const HSP_KSP_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018938i32 as _);
pub const HSP_KSP_NO_MEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018928i32 as _);
pub const HSP_KSP_NO_MORE_ITEMS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018920i32 as _);
pub const HSP_KSP_PARAMETER_NOT_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2128018927i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct HSTR__ {
pub unused: i32,
}
impl HSTR__ {}
impl ::core::default::Default for HSTR__ {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for HSTR__ {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("HSTR__").field("unused", &self.unused).finish()
}
}
impl ::core::cmp::PartialEq for HSTR__ {
fn eq(&self, other: &Self) -> bool {
self.unused == other.unused
}
}
impl ::core::cmp::Eq for HSTR__ {}
unsafe impl ::windows::core::Abi for HSTR__ {
type Abi = Self;
}
pub const HTTP_E_STATUS_AMBIGUOUS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844948i32 as _);
pub const HTTP_E_STATUS_BAD_GATEWAY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844746i32 as _);
pub const HTTP_E_STATUS_BAD_METHOD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844843i32 as _);
pub const HTTP_E_STATUS_BAD_REQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844848i32 as _);
pub const HTTP_E_STATUS_CONFLICT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844839i32 as _);
pub const HTTP_E_STATUS_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844847i32 as _);
pub const HTTP_E_STATUS_EXPECTATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844831i32 as _);
pub const HTTP_E_STATUS_FORBIDDEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844845i32 as _);
pub const HTTP_E_STATUS_GATEWAY_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844744i32 as _);
pub const HTTP_E_STATUS_GONE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844838i32 as _);
pub const HTTP_E_STATUS_LENGTH_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844837i32 as _);
pub const HTTP_E_STATUS_MOVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844947i32 as _);
pub const HTTP_E_STATUS_NONE_ACCEPTABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844842i32 as _);
pub const HTTP_E_STATUS_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844844i32 as _);
pub const HTTP_E_STATUS_NOT_MODIFIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844944i32 as _);
pub const HTTP_E_STATUS_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844747i32 as _);
pub const HTTP_E_STATUS_PAYMENT_REQ: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844846i32 as _);
pub const HTTP_E_STATUS_PRECOND_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844836i32 as _);
pub const HTTP_E_STATUS_PROXY_AUTH_REQ: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844841i32 as _);
pub const HTTP_E_STATUS_RANGE_NOT_SATISFIABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844832i32 as _);
pub const HTTP_E_STATUS_REDIRECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844946i32 as _);
pub const HTTP_E_STATUS_REDIRECT_KEEP_VERB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844941i32 as _);
pub const HTTP_E_STATUS_REDIRECT_METHOD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844945i32 as _);
pub const HTTP_E_STATUS_REQUEST_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844840i32 as _);
pub const HTTP_E_STATUS_REQUEST_TOO_LARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844835i32 as _);
pub const HTTP_E_STATUS_SERVER_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844748i32 as _);
pub const HTTP_E_STATUS_SERVICE_UNAVAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844745i32 as _);
pub const HTTP_E_STATUS_UNEXPECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145845247i32 as _);
pub const HTTP_E_STATUS_UNEXPECTED_CLIENT_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145845244i32 as _);
pub const HTTP_E_STATUS_UNEXPECTED_REDIRECTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145845245i32 as _);
pub const HTTP_E_STATUS_UNEXPECTED_SERVER_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145845243i32 as _);
pub const HTTP_E_STATUS_UNSUPPORTED_MEDIA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844833i32 as _);
pub const HTTP_E_STATUS_URI_TOO_LONG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844834i32 as _);
pub const HTTP_E_STATUS_USE_PROXY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844943i32 as _);
pub const HTTP_E_STATUS_VERSION_NOT_SUP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145844743i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct HUMPD__ {
pub unused: i32,
}
impl HUMPD__ {}
impl ::core::default::Default for HUMPD__ {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for HUMPD__ {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("HUMPD__").field("unused", &self.unused).finish()
}
}
impl ::core::cmp::PartialEq for HUMPD__ {
fn eq(&self, other: &Self) -> bool {
self.unused == other.unused
}
}
impl ::core::cmp::Eq for HUMPD__ {}
unsafe impl ::windows::core::Abi for HUMPD__ {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct HWND(pub isize);
impl ::core::default::Default for HWND {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
unsafe impl ::windows::core::Handle for HWND {}
unsafe impl ::windows::core::Abi for HWND {
type Abi = Self;
}
pub const INPLACE_E_FIRST: i32 = -2147221088i32;
pub const INPLACE_E_LAST: i32 = -2147221073i32;
pub const INPLACE_E_NOTOOLSPACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221087i32 as _);
pub const INPLACE_E_NOTUNDOABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221088i32 as _);
pub const INPLACE_S_FIRST: i32 = 262560i32;
pub const INPLACE_S_LAST: i32 = 262575i32;
pub const INPLACE_S_TRUNCATED: ::windows::core::HRESULT = ::windows::core::HRESULT(262560i32 as _);
pub const INPUT_E_DEVICE_INFO: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143289338i32 as _);
pub const INPUT_E_DEVICE_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143289336i32 as _);
pub const INPUT_E_FRAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143289340i32 as _);
pub const INPUT_E_HISTORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143289339i32 as _);
pub const INPUT_E_MULTIMODAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143289342i32 as _);
pub const INPUT_E_OUT_OF_ORDER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143289344i32 as _);
pub const INPUT_E_PACKET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143289341i32 as _);
pub const INPUT_E_REENTRANCY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143289343i32 as _);
pub const INPUT_E_TRANSFORM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143289337i32 as _);
pub const INVALID_HANDLE_VALUE: HANDLE = HANDLE(-1i32 as _);
pub const IORING_E_COMPLETION_QUEUE_TOO_BIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2142896123i32 as _);
pub const IORING_E_CORRUPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2142896121i32 as _);
pub const IORING_E_REQUIRED_FLAG_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2142896127i32 as _);
pub const IORING_E_SUBMISSION_QUEUE_FULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2142896126i32 as _);
pub const IORING_E_SUBMISSION_QUEUE_TOO_BIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2142896124i32 as _);
pub const IORING_E_SUBMIT_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2142896122i32 as _);
pub const IORING_E_VERSION_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2142896125i32 as _);
pub const JSCRIPT_E_CANTEXECUTE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1996357631i32 as _);
pub const LANGUAGE_E_DATABASE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215484i32 as _);
pub const LANGUAGE_S_LARGE_WORD: ::windows::core::HRESULT = ::windows::core::HRESULT(268161i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct LPARAM(pub isize);
impl ::core::default::Default for LPARAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
unsafe impl ::windows::core::Handle for LPARAM {}
unsafe impl ::windows::core::Abi for LPARAM {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct LRESULT(pub isize);
impl ::core::default::Default for LRESULT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
unsafe impl ::windows::core::Handle for LRESULT {}
unsafe impl ::windows::core::Abi for LRESULT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct LSTATUS(pub i32);
impl ::core::default::Default for LSTATUS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
unsafe impl ::windows::core::Handle for LSTATUS {}
unsafe impl ::windows::core::Abi for LSTATUS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct LUID {
pub LowPart: u32,
pub HighPart: i32,
}
impl LUID {}
impl ::core::default::Default for LUID {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for LUID {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("LUID").field("LowPart", &self.LowPart).field("HighPart", &self.HighPart).finish()
}
}
impl ::core::cmp::PartialEq for LUID {
fn eq(&self, other: &Self) -> bool {
self.LowPart == other.LowPart && self.HighPart == other.HighPart
}
}
impl ::core::cmp::Eq for LUID {}
unsafe impl ::windows::core::Abi for LUID {
type Abi = Self;
}
pub const MARSHAL_E_FIRST: i32 = -2147221216i32;
pub const MARSHAL_E_LAST: i32 = -2147221201i32;
pub const MARSHAL_S_FIRST: i32 = 262432i32;
pub const MARSHAL_S_LAST: i32 = 262447i32;
pub const MAX_PATH: u32 = 260u32;
pub const MEM_E_INVALID_LINK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959344i32 as _);
pub const MEM_E_INVALID_ROOT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959351i32 as _);
pub const MEM_E_INVALID_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959343i32 as _);
pub const MENROLL_S_ENROLLMENT_SUSPENDED: ::windows::core::HRESULT = ::windows::core::HRESULT(1572881i32 as _);
pub const MILAVERR_INSUFFICIENTVIDEORESOURCES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303160i32 as _);
pub const MILAVERR_INVALIDWMPVERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303161i32 as _);
pub const MILAVERR_MEDIAPLAYERCLOSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303155i32 as _);
pub const MILAVERR_MODULENOTLOADED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303163i32 as _);
pub const MILAVERR_NOCLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303168i32 as _);
pub const MILAVERR_NOMEDIATYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303167i32 as _);
pub const MILAVERR_NOREADYFRAMES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303164i32 as _);
pub const MILAVERR_NOVIDEOMIXER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303166i32 as _);
pub const MILAVERR_NOVIDEOPRESENTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303165i32 as _);
pub const MILAVERR_REQUESTEDTEXTURETOOBIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303158i32 as _);
pub const MILAVERR_SEEKFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303157i32 as _);
pub const MILAVERR_UNEXPECTEDWMPFAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303156i32 as _);
pub const MILAVERR_UNKNOWNHARDWAREERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303154i32 as _);
pub const MILAVERR_VIDEOACCELERATIONNOTAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303159i32 as _);
pub const MILAVERR_WMPFACTORYNOTREGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303162i32 as _);
pub const MILEFFECTSERR_ALREADYATTACHEDTOLISTENER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302888i32 as _);
pub const MILEFFECTSERR_CONNECTORNOTASSOCIATEDWITHEFFECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302894i32 as _);
pub const MILEFFECTSERR_CONNECTORNOTCONNECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302895i32 as _);
pub const MILEFFECTSERR_CYCLEDETECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302892i32 as _);
pub const MILEFFECTSERR_EFFECTALREADYINAGRAPH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302890i32 as _);
pub const MILEFFECTSERR_EFFECTHASNOCHILDREN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302889i32 as _);
pub const MILEFFECTSERR_EFFECTINMORETHANONEGRAPH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302891i32 as _);
pub const MILEFFECTSERR_EFFECTNOTPARTOFGROUP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302897i32 as _);
pub const MILEFFECTSERR_EMPTYBOUNDS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302886i32 as _);
pub const MILEFFECTSERR_NOINPUTSOURCEATTACHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302896i32 as _);
pub const MILEFFECTSERR_NOTAFFINETRANSFORM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302887i32 as _);
pub const MILEFFECTSERR_OUTPUTSIZETOOLARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302885i32 as _);
pub const MILEFFECTSERR_RESERVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302893i32 as _);
pub const MILEFFECTSERR_UNKNOWNPROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003302898i32 as _);
pub const MILERR_ADAPTER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304290i32 as _);
pub const MILERR_ALREADYLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304314i32 as _);
pub const MILERR_ALREADY_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304305i32 as _);
pub const MILERR_BADNUMBER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304438i32 as _);
pub const MILERR_COLORSPACE_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304289i32 as _);
pub const MILERR_DEVICECANNOTRENDERTEXT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304312i32 as _);
pub const MILERR_DISPLAYFORMATNOTSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304316i32 as _);
pub const MILERR_DISPLAYID_ACCESS_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304287i32 as _);
pub const MILERR_DISPLAYSTATEINVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304442i32 as _);
pub const MILERR_DXGI_ENUMERATION_OUT_OF_SYNC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304291i32 as _);
pub const MILERR_GENERIC_IGNORE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304309i32 as _);
pub const MILERR_GLYPHBITMAPMISSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304311i32 as _);
pub const MILERR_INSUFFICIENTBUFFER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304446i32 as _);
pub const MILERR_INTERNALERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304320i32 as _);
pub const MILERR_INVALIDCALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304315i32 as _);
pub const MILERR_MALFORMEDGLYPHCACHE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304310i32 as _);
pub const MILERR_MALFORMED_GUIDELINE_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304308i32 as _);
pub const MILERR_MAX_TEXTURE_SIZE_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304294i32 as _);
pub const MILERR_MISMATCHED_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304304i32 as _);
pub const MILERR_MROW_READLOCK_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304297i32 as _);
pub const MILERR_MROW_UPDATE_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304296i32 as _);
pub const MILERR_NEED_RECREATE_AND_PRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304306i32 as _);
pub const MILERR_NONINVERTIBLEMATRIX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304441i32 as _);
pub const MILERR_NOTLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304313i32 as _);
pub const MILERR_NOT_QUEUING_PRESENTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304300i32 as _);
pub const MILERR_NO_HARDWARE_DEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304307i32 as _);
pub const MILERR_NO_REDIRECTION_SURFACE_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304303i32 as _);
pub const MILERR_NO_REDIRECTION_SURFACE_RETRY_LATER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304299i32 as _);
pub const MILERR_OBJECTBUSY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304447i32 as _);
pub const MILERR_PREFILTER_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304288i32 as _);
pub const MILERR_QPC_TIME_WENT_BACKWARD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304293i32 as _);
pub const MILERR_QUEUED_PRESENT_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304301i32 as _);
pub const MILERR_REMOTING_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304302i32 as _);
pub const MILERR_SCANNER_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304444i32 as _);
pub const MILERR_SCREENACCESSDENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304443i32 as _);
pub const MILERR_SHADER_COMPILE_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304295i32 as _);
pub const MILERR_TERMINATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304439i32 as _);
pub const MILERR_TOOMANYSHADERELEMNTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304298i32 as _);
pub const MILERR_WIN32ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304445i32 as _);
pub const MILERR_ZEROVECTOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003304440i32 as _);
pub const MK_E_CANTOPENFILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221014i32 as _);
pub const MK_E_CONNECTMANUALLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221024i32 as _);
pub const MK_E_ENUMERATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221009i32 as _);
pub const MK_E_EXCEEDEDDEADLINE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221023i32 as _);
pub const MK_E_FIRST: i32 = -2147221024i32;
pub const MK_E_INTERMEDIATEINTERFACENOTSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221017i32 as _);
pub const MK_E_INVALIDEXTENSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221018i32 as _);
pub const MK_E_LAST: i32 = -2147221009i32;
pub const MK_E_MUSTBOTHERUSER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221013i32 as _);
pub const MK_E_NEEDGENERIC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221022i32 as _);
pub const MK_E_NOINVERSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221012i32 as _);
pub const MK_E_NOOBJECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221019i32 as _);
pub const MK_E_NOPREFIX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221010i32 as _);
pub const MK_E_NOSTORAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221011i32 as _);
pub const MK_E_NOTBINDABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221016i32 as _);
pub const MK_E_NOTBOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221015i32 as _);
pub const MK_E_NO_NORMALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146959353i32 as _);
pub const MK_E_SYNTAX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221020i32 as _);
pub const MK_E_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221021i32 as _);
pub const MK_S_FIRST: i32 = 262624i32;
pub const MK_S_HIM: ::windows::core::HRESULT = ::windows::core::HRESULT(262629i32 as _);
pub const MK_S_LAST: i32 = 262639i32;
pub const MK_S_ME: ::windows::core::HRESULT = ::windows::core::HRESULT(262628i32 as _);
pub const MK_S_MONIKERALREADYREGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(262631i32 as _);
pub const MK_S_REDUCED_TO_SELF: ::windows::core::HRESULT = ::windows::core::HRESULT(262626i32 as _);
pub const MK_S_US: ::windows::core::HRESULT = ::windows::core::HRESULT(262630i32 as _);
pub const MSDTC_E_DUPLICATE_RESOURCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146367743i32 as _);
pub const MSSIPOTF_E_BADVERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865131i32 as _);
pub const MSSIPOTF_E_BAD_FIRST_TABLE_PLACEMENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865144i32 as _);
pub const MSSIPOTF_E_BAD_MAGICNUMBER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865148i32 as _);
pub const MSSIPOTF_E_BAD_OFFSET_TABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865147i32 as _);
pub const MSSIPOTF_E_CANTGETOBJECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865150i32 as _);
pub const MSSIPOTF_E_CRYPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865132i32 as _);
pub const MSSIPOTF_E_DSIG_STRUCTURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865130i32 as _);
pub const MSSIPOTF_E_FAILED_HINTS_CHECK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865135i32 as _);
pub const MSSIPOTF_E_FAILED_POLICY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865136i32 as _);
pub const MSSIPOTF_E_FILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865133i32 as _);
pub const MSSIPOTF_E_FILETOOSMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865141i32 as _);
pub const MSSIPOTF_E_FILE_CHECKSUM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865139i32 as _);
pub const MSSIPOTF_E_NOHEADTABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865149i32 as _);
pub const MSSIPOTF_E_NOT_OPENTYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865134i32 as _);
pub const MSSIPOTF_E_OUTOFMEMRANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865151i32 as _);
pub const MSSIPOTF_E_PCONST_CHECK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865129i32 as _);
pub const MSSIPOTF_E_STRUCTURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865128i32 as _);
pub const MSSIPOTF_E_TABLES_OVERLAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865143i32 as _);
pub const MSSIPOTF_E_TABLE_CHECKSUM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865140i32 as _);
pub const MSSIPOTF_E_TABLE_LONGWORD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865145i32 as _);
pub const MSSIPOTF_E_TABLE_PADBYTES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865142i32 as _);
pub const MSSIPOTF_E_TABLE_TAGORDER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146865146i32 as _);
pub const NAP_E_CONFLICTING_ID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927741i32 as _);
pub const NAP_E_ENTITY_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927730i32 as _);
pub const NAP_E_ID_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927734i32 as _);
pub const NAP_E_INVALID_PACKET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927743i32 as _);
pub const NAP_E_MAXSIZE_TOO_SMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927733i32 as _);
pub const NAP_E_MISMATCHED_ID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927736i32 as _);
pub const NAP_E_MISSING_SOH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927742i32 as _);
pub const NAP_E_NETSH_GROUPPOLICY_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927729i32 as _);
pub const NAP_E_NOT_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927737i32 as _);
pub const NAP_E_NOT_PENDING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927735i32 as _);
pub const NAP_E_NOT_REGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927738i32 as _);
pub const NAP_E_NO_CACHED_SOH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927740i32 as _);
pub const NAP_E_SERVICE_NOT_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927732i32 as _);
pub const NAP_E_SHV_CONFIG_EXISTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927727i32 as _);
pub const NAP_E_SHV_CONFIG_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927726i32 as _);
pub const NAP_E_SHV_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927725i32 as _);
pub const NAP_E_STILL_BOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927739i32 as _);
pub const NAP_E_TOO_MANY_CALLS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144927728i32 as _);
pub const NAP_S_CERT_ALREADY_PRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(2555917i32 as _);
pub type NEARPROC = unsafe extern "system" fn() -> isize;
pub const NOERROR: u32 = 0u32;
pub const NOT_AN_ERROR1: ::windows::core::HRESULT = ::windows::core::HRESULT(529920i32 as _);
pub const NTDDI_MAXVER: u32 = 2560u32;
pub const NTE_AUTHENTICATION_IGNORED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893775i32 as _);
pub const NTE_BAD_ALGID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893816i32 as _);
pub const NTE_BAD_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893819i32 as _);
pub const NTE_BAD_FLAGS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893815i32 as _);
pub const NTE_BAD_HASH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893822i32 as _);
pub const NTE_BAD_HASH_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893812i32 as _);
pub const NTE_BAD_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893821i32 as _);
pub const NTE_BAD_KEYSET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893802i32 as _);
pub const NTE_BAD_KEYSET_PARAM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893793i32 as _);
pub const NTE_BAD_KEY_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893813i32 as _);
pub const NTE_BAD_LEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893820i32 as _);
pub const NTE_BAD_PROVIDER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893805i32 as _);
pub const NTE_BAD_PROV_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893804i32 as _);
pub const NTE_BAD_PUBLIC_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893803i32 as _);
pub const NTE_BAD_SIGNATURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893818i32 as _);
pub const NTE_BAD_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893814i32 as _);
pub const NTE_BAD_UID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893823i32 as _);
pub const NTE_BAD_VER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893817i32 as _);
pub const NTE_BUFFERS_OVERLAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893781i32 as _);
pub const NTE_BUFFER_TOO_SMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893784i32 as _);
pub const NTE_DECRYPTION_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893780i32 as _);
pub const NTE_DEVICE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893771i32 as _);
pub const NTE_DEVICE_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893776i32 as _);
pub const NTE_DOUBLE_ENCRYPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893806i32 as _);
pub const NTE_ENCRYPTION_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893772i32 as _);
pub const NTE_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893809i32 as _);
pub const NTE_FAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893792i32 as _);
pub const NTE_FIXEDPARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893787i32 as _);
pub const NTE_HMAC_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893777i32 as _);
pub const NTE_INCORRECT_PASSWORD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893773i32 as _);
pub const NTE_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893779i32 as _);
pub const NTE_INVALID_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893786i32 as _);
pub const NTE_INVALID_PARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893785i32 as _);
pub const NTE_KEYSET_ENTRY_BAD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893798i32 as _);
pub const NTE_KEYSET_NOT_DEF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893799i32 as _);
pub const NTE_NOT_ACTIVE_CONSOLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893768i32 as _);
pub const NTE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893807i32 as _);
pub const NTE_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893783i32 as _);
pub const NTE_NO_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893811i32 as _);
pub const NTE_NO_MEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893810i32 as _);
pub const NTE_NO_MORE_ITEMS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893782i32 as _);
pub const NTE_OP_OK: u32 = 0u32;
pub const NTE_PASSWORD_CHANGE_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893769i32 as _);
pub const NTE_PERM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893808i32 as _);
pub const NTE_PROVIDER_DLL_FAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893795i32 as _);
pub const NTE_PROV_DLL_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893794i32 as _);
pub const NTE_PROV_TYPE_ENTRY_BAD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893800i32 as _);
pub const NTE_PROV_TYPE_NOT_DEF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893801i32 as _);
pub const NTE_PROV_TYPE_NO_MATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893797i32 as _);
pub const NTE_SIGNATURE_FILE_BAD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893796i32 as _);
pub const NTE_SILENT_CONTEXT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893790i32 as _);
pub const NTE_SYS_ERR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893791i32 as _);
pub const NTE_TEMPORARY_PROFILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893788i32 as _);
pub const NTE_TOKEN_KEYSET_STORAGE_FULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893789i32 as _);
pub const NTE_UI_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893778i32 as _);
pub const NTE_USER_CANCELLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893770i32 as _);
pub const NTE_VALIDATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893774i32 as _);
#[repr(transparent)]
#[derive(:: core :: default :: Default, :: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: fmt :: Debug)]
pub struct NTSTATUS(pub u32);
impl NTSTATUS {
#[inline]
pub const fn is_ok(self) -> bool {
self.0 & 0x8000_0000 == 0
}
#[inline]
pub const fn is_err(self) -> bool {
!self.is_ok()
}
#[inline]
pub const fn to_hresult(self) -> ::windows::core::HRESULT {
::windows::core::HRESULT(self.0 | 0x1000_0000)
}
#[inline]
pub fn ok(self) -> ::windows::core::Result<()> {
if self.is_ok() {
Ok(())
} else {
Err(::windows::core::Error::fast_error(self.to_hresult()))
}
}
}
unsafe impl ::windows::core::Abi for NTSTATUS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct NTSTATUS_FACILITY_CODE(pub u32);
pub const FACILITY_DEBUGGER: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(1u32);
pub const FACILITY_RPC_RUNTIME: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(2u32);
pub const FACILITY_RPC_STUBS: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(3u32);
pub const FACILITY_IO_ERROR_CODE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(4u32);
pub const FACILITY_CODCLASS_ERROR_CODE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(6u32);
pub const FACILITY_NTWIN32: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(7u32);
pub const FACILITY_NTCERT: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(8u32);
pub const FACILITY_NTSSPI: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(9u32);
pub const FACILITY_TERMINAL_SERVER: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(10u32);
pub const FACILITY_USB_ERROR_CODE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(16u32);
pub const FACILITY_HID_ERROR_CODE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(17u32);
pub const FACILITY_FIREWIRE_ERROR_CODE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(18u32);
pub const FACILITY_CLUSTER_ERROR_CODE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(19u32);
pub const FACILITY_ACPI_ERROR_CODE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(20u32);
pub const FACILITY_SXS_ERROR_CODE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(21u32);
pub const FACILITY_TRANSACTION: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(25u32);
pub const FACILITY_COMMONLOG: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(26u32);
pub const FACILITY_VIDEO: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(27u32);
pub const FACILITY_FILTER_MANAGER: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(28u32);
pub const FACILITY_MONITOR: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(29u32);
pub const FACILITY_GRAPHICS_KERNEL: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(30u32);
pub const FACILITY_DRIVER_FRAMEWORK: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(32u32);
pub const FACILITY_FVE_ERROR_CODE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(33u32);
pub const FACILITY_FWP_ERROR_CODE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(34u32);
pub const FACILITY_NDIS_ERROR_CODE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(35u32);
pub const FACILITY_QUIC_ERROR_CODE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(36u32);
pub const FACILITY_TPM: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(41u32);
pub const FACILITY_RTPM: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(42u32);
pub const FACILITY_HYPERVISOR: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(53u32);
pub const FACILITY_IPSEC: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(54u32);
pub const FACILITY_VIRTUALIZATION: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(55u32);
pub const FACILITY_VOLMGR: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(56u32);
pub const FACILITY_BCD_ERROR_CODE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(57u32);
pub const FACILITY_WIN32K_NTUSER: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(62u32);
pub const FACILITY_WIN32K_NTGDI: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(63u32);
pub const FACILITY_RESUME_KEY_FILTER: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(64u32);
pub const FACILITY_RDBSS: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(65u32);
pub const FACILITY_BTH_ATT: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(66u32);
pub const FACILITY_SECUREBOOT: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(67u32);
pub const FACILITY_AUDIO_KERNEL: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(68u32);
pub const FACILITY_VSM: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(69u32);
pub const FACILITY_NT_IORING: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(70u32);
pub const FACILITY_VOLSNAP: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(80u32);
pub const FACILITY_SDBUS: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(81u32);
pub const FACILITY_SHARED_VHDX: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(92u32);
pub const FACILITY_SMB: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(93u32);
pub const FACILITY_XVS: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(94u32);
pub const FACILITY_INTERIX: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(153u32);
pub const FACILITY_SPACES: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(231u32);
pub const FACILITY_SECURITY_CORE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(232u32);
pub const FACILITY_SYSTEM_INTEGRITY: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(233u32);
pub const FACILITY_LICENSING: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(234u32);
pub const FACILITY_PLATFORM_MANIFEST: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(235u32);
pub const FACILITY_APP_EXEC: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(236u32);
pub const FACILITY_MAXIMUM_VALUE: NTSTATUS_FACILITY_CODE = NTSTATUS_FACILITY_CODE(237u32);
impl ::core::convert::From<u32> for NTSTATUS_FACILITY_CODE {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for NTSTATUS_FACILITY_CODE {
type Abi = Self;
}
impl ::core::ops::BitOr for NTSTATUS_FACILITY_CODE {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for NTSTATUS_FACILITY_CODE {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for NTSTATUS_FACILITY_CODE {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for NTSTATUS_FACILITY_CODE {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for NTSTATUS_FACILITY_CODE {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const OLEOBJ_E_FIRST: i32 = -2147221120i32;
pub const OLEOBJ_E_INVALIDVERB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221119i32 as _);
pub const OLEOBJ_E_LAST: i32 = -2147221105i32;
pub const OLEOBJ_E_NOVERBS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221120i32 as _);
pub const OLEOBJ_S_CANNOT_DOVERB_NOW: ::windows::core::HRESULT = ::windows::core::HRESULT(262529i32 as _);
pub const OLEOBJ_S_FIRST: i32 = 262528i32;
pub const OLEOBJ_S_INVALIDHWND: ::windows::core::HRESULT = ::windows::core::HRESULT(262530i32 as _);
pub const OLEOBJ_S_INVALIDVERB: ::windows::core::HRESULT = ::windows::core::HRESULT(262528i32 as _);
pub const OLEOBJ_S_LAST: i32 = 262543i32;
pub const OLE_E_ADVF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221503i32 as _);
pub const OLE_E_ADVISENOTSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221501i32 as _);
pub const OLE_E_BLANK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221497i32 as _);
pub const OLE_E_CANTCONVERT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221487i32 as _);
pub const OLE_E_CANT_BINDTOSOURCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221494i32 as _);
pub const OLE_E_CANT_GETMONIKER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221495i32 as _);
pub const OLE_E_CLASSDIFF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221496i32 as _);
pub const OLE_E_ENUM_NOMORE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221502i32 as _);
pub const OLE_E_FIRST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221504i32 as _);
pub const OLE_E_INVALIDHWND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221489i32 as _);
pub const OLE_E_INVALIDRECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221491i32 as _);
pub const OLE_E_LAST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221249i32 as _);
pub const OLE_E_NOCACHE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221498i32 as _);
pub const OLE_E_NOCONNECTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221500i32 as _);
pub const OLE_E_NOSTORAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221486i32 as _);
pub const OLE_E_NOTRUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221499i32 as _);
pub const OLE_E_NOT_INPLACEACTIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221488i32 as _);
pub const OLE_E_OLEVERB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221504i32 as _);
pub const OLE_E_PROMPTSAVECANCELLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221492i32 as _);
pub const OLE_E_STATIC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221493i32 as _);
pub const OLE_E_WRONGCOMPOBJ: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221490i32 as _);
pub const OLE_S_FIRST: ::windows::core::HRESULT = ::windows::core::HRESULT(262144i32 as _);
pub const OLE_S_LAST: ::windows::core::HRESULT = ::windows::core::HRESULT(262399i32 as _);
pub const OLE_S_MAC_CLIPFORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(262146i32 as _);
pub const OLE_S_STATIC: ::windows::core::HRESULT = ::windows::core::HRESULT(262145i32 as _);
pub const OLE_S_USEREG: ::windows::core::HRESULT = ::windows::core::HRESULT(262144i32 as _);
pub const ONL_CONNECTION_COUNT_LIMIT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701811i32 as _);
pub const ONL_E_ACCESS_DENIED_BY_TOU: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701822i32 as _);
pub const ONL_E_ACCOUNT_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701817i32 as _);
pub const ONL_E_ACCOUNT_SUSPENDED_ABUSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701813i32 as _);
pub const ONL_E_ACCOUNT_SUSPENDED_COMPROIMISE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701814i32 as _);
pub const ONL_E_ACCOUNT_UPDATE_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701819i32 as _);
pub const ONL_E_ACTION_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701812i32 as _);
pub const ONL_E_CONNECTED_ACCOUNT_CAN_NOT_SIGNOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701810i32 as _);
pub const ONL_E_EMAIL_VERIFICATION_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701815i32 as _);
pub const ONL_E_FORCESIGNIN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701818i32 as _);
pub const ONL_E_INVALID_APPLICATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701821i32 as _);
pub const ONL_E_INVALID_AUTHENTICATION_TARGET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701823i32 as _);
pub const ONL_E_PARENTAL_CONSENT_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701816i32 as _);
pub const ONL_E_PASSWORD_UPDATE_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701820i32 as _);
pub const ONL_E_REQUEST_THROTTLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701808i32 as _);
pub const ONL_E_USER_AUTHENTICATION_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2138701809i32 as _);
pub const OR_INVALID_OID: i32 = 1911i32;
pub const OR_INVALID_OXID: i32 = 1910i32;
pub const OR_INVALID_SET: i32 = 1912i32;
pub const OSS_ACCESS_SERIALIZATION_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881517i32 as _);
pub const OSS_API_DLL_NOT_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881495i32 as _);
pub const OSS_BAD_ARG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881530i32 as _);
pub const OSS_BAD_ENCRULES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881514i32 as _);
pub const OSS_BAD_PTR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881525i32 as _);
pub const OSS_BAD_TABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881521i32 as _);
pub const OSS_BAD_TIME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881524i32 as _);
pub const OSS_BAD_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881529i32 as _);
pub const OSS_BERDER_DLL_NOT_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881494i32 as _);
pub const OSS_CANT_CLOSE_TRACE_FILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881490i32 as _);
pub const OSS_CANT_OPEN_TRACE_FILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881509i32 as _);
pub const OSS_CANT_OPEN_TRACE_WINDOW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881512i32 as _);
pub const OSS_COMPARATOR_CODE_NOT_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881499i32 as _);
pub const OSS_COMPARATOR_DLL_NOT_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881500i32 as _);
pub const OSS_CONSTRAINT_DLL_NOT_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881501i32 as _);
pub const OSS_CONSTRAINT_VIOLATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881519i32 as _);
pub const OSS_COPIER_DLL_NOT_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881502i32 as _);
pub const OSS_DATA_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881531i32 as _);
pub const OSS_FATAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881518i32 as _);
pub const OSS_INDEFINITE_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881523i32 as _);
pub const OSS_LIMITED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881526i32 as _);
pub const OSS_MEM_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881522i32 as _);
pub const OSS_MEM_MGR_DLL_NOT_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881498i32 as _);
pub const OSS_MORE_BUF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881535i32 as _);
pub const OSS_MORE_INPUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881532i32 as _);
pub const OSS_MUTEX_NOT_CREATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881491i32 as _);
pub const OSS_NEGATIVE_UINTEGER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881534i32 as _);
pub const OSS_NULL_FCN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881515i32 as _);
pub const OSS_NULL_TBL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881516i32 as _);
pub const OSS_OID_DLL_NOT_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881510i32 as _);
pub const OSS_OPEN_TYPE_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881492i32 as _);
pub const OSS_OUT_MEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881528i32 as _);
pub const OSS_OUT_OF_RANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881503i32 as _);
pub const OSS_PDU_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881527i32 as _);
pub const OSS_PDU_RANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881533i32 as _);
pub const OSS_PDV_CODE_NOT_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881496i32 as _);
pub const OSS_PDV_DLL_NOT_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881497i32 as _);
pub const OSS_PER_DLL_NOT_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881493i32 as _);
pub const OSS_REAL_CODE_NOT_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881504i32 as _);
pub const OSS_REAL_DLL_NOT_LINKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881505i32 as _);
pub const OSS_TABLE_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881507i32 as _);
pub const OSS_TOO_LONG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881520i32 as _);
pub const OSS_TRACE_FILE_ALREADY_OPEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881508i32 as _);
pub const OSS_TYPE_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881506i32 as _);
pub const OSS_UNAVAIL_ENCRULES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881513i32 as _);
pub const OSS_UNIMPLEMENTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146881511i32 as _);
pub type PAPCFUNC = unsafe extern "system" fn(parameter: usize);
pub const PEERDIST_ERROR_ALREADY_COMPLETED: i32 = 4060i32;
pub const PEERDIST_ERROR_ALREADY_EXISTS: i32 = 4058i32;
pub const PEERDIST_ERROR_ALREADY_INITIALIZED: i32 = 4055i32;
pub const PEERDIST_ERROR_CANNOT_PARSE_CONTENTINFO: i32 = 4051i32;
pub const PEERDIST_ERROR_CONTENTINFO_VERSION_UNSUPPORTED: i32 = 4050i32;
pub const PEERDIST_ERROR_INVALIDATED: i32 = 4057i32;
pub const PEERDIST_ERROR_INVALID_CONFIGURATION: i32 = 4063i32;
pub const PEERDIST_ERROR_MISSING_DATA: i32 = 4052i32;
pub const PEERDIST_ERROR_NOT_INITIALIZED: i32 = 4054i32;
pub const PEERDIST_ERROR_NOT_LICENSED: i32 = 4064i32;
pub const PEERDIST_ERROR_NO_MORE: i32 = 4053i32;
pub const PEERDIST_ERROR_OPERATION_NOTFOUND: i32 = 4059i32;
pub const PEERDIST_ERROR_OUT_OF_BOUNDS: i32 = 4061i32;
pub const PEERDIST_ERROR_SERVICE_UNAVAILABLE: i32 = 4065i32;
pub const PEERDIST_ERROR_SHUTDOWN_IN_PROGRESS: i32 = 4056i32;
pub const PEERDIST_ERROR_TRUST_FAILURE: i32 = 4066i32;
pub const PEERDIST_ERROR_VERSION_UNSUPPORTED: i32 = 4062i32;
pub const PEER_E_ALREADY_LISTENING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995321i32 as _);
pub const PEER_E_CANNOT_CONVERT_PEER_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140979199i32 as _);
pub const PEER_E_CANNOT_START_SERVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995581i32 as _);
pub const PEER_E_CERT_STORE_CORRUPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140993535i32 as _);
pub const PEER_E_CHAIN_TOO_LONG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140993789i32 as _);
pub const PEER_E_CIRCULAR_CHAIN_DETECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140993786i32 as _);
pub const PEER_E_CLASSIFIER_TOO_LONG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995071i32 as _);
pub const PEER_E_CLOUD_NAME_AMBIGUOUS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140991483i32 as _);
pub const PEER_E_CONNECTION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995319i32 as _);
pub const PEER_E_CONNECTION_NOT_AUTHENTICATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995318i32 as _);
pub const PEER_E_CONNECTION_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995325i32 as _);
pub const PEER_E_CONNECTION_REFUSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995317i32 as _);
pub const PEER_E_CONNECT_SELF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995322i32 as _);
pub const PEER_E_CONTACT_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140971007i32 as _);
pub const PEER_E_DATABASE_ACCESSDENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140994814i32 as _);
pub const PEER_E_DATABASE_ALREADY_PRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140994811i32 as _);
pub const PEER_E_DATABASE_NOT_PRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140994810i32 as _);
pub const PEER_E_DBINITIALIZATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140994813i32 as _);
pub const PEER_E_DBNAME_CHANGED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995567i32 as _);
pub const PEER_E_DEFERRED_VALIDATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987344i32 as _);
pub const PEER_E_DUPLICATE_GRAPH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995566i32 as _);
pub const PEER_E_EVENT_HANDLE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140994303i32 as _);
pub const PEER_E_FW_BLOCKED_BY_POLICY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140966903i32 as _);
pub const PEER_E_FW_BLOCKED_BY_SHIELDS_UP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140966902i32 as _);
pub const PEER_E_FW_DECLINED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140966901i32 as _);
pub const PEER_E_FW_EXCEPTION_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140966904i32 as _);
pub const PEER_E_GRAPH_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995563i32 as _);
pub const PEER_E_GRAPH_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995565i32 as _);
pub const PEER_E_GRAPH_SHUTTING_DOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995564i32 as _);
pub const PEER_E_GROUPS_EXIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995068i32 as _);
pub const PEER_E_GROUP_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987246i32 as _);
pub const PEER_E_GROUP_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987247i32 as _);
pub const PEER_E_IDENTITY_DELETED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987232i32 as _);
pub const PEER_E_IDENTITY_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140994559i32 as _);
pub const PEER_E_INVALID_ADDRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140966905i32 as _);
pub const PEER_E_INVALID_ATTRIBUTES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140994046i32 as _);
pub const PEER_E_INVALID_CLASSIFIER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987296i32 as _);
pub const PEER_E_INVALID_CLASSIFIER_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987278i32 as _);
pub const PEER_E_INVALID_CREDENTIAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987262i32 as _);
pub const PEER_E_INVALID_CREDENTIAL_INFO: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987263i32 as _);
pub const PEER_E_INVALID_DATABASE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995562i32 as _);
pub const PEER_E_INVALID_FRIENDLY_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987280i32 as _);
pub const PEER_E_INVALID_GRAPH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995568i32 as _);
pub const PEER_E_INVALID_GROUP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987245i32 as _);
pub const PEER_E_INVALID_GROUP_PROPERTIES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987328i32 as _);
pub const PEER_E_INVALID_PEER_HOST_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140979198i32 as _);
pub const PEER_E_INVALID_PEER_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987312i32 as _);
pub const PEER_E_INVALID_RECORD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987376i32 as _);
pub const PEER_E_INVALID_RECORD_EXPIRATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987264i32 as _);
pub const PEER_E_INVALID_RECORD_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987261i32 as _);
pub const PEER_E_INVALID_ROLE_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987279i32 as _);
pub const PEER_E_INVALID_SEARCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140994047i32 as _);
pub const PEER_E_INVALID_TIME_PERIOD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140993787i32 as _);
pub const PEER_E_INVITATION_NOT_TRUSTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140993791i32 as _);
pub const PEER_E_INVITE_CANCELLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140966912i32 as _);
pub const PEER_E_INVITE_RESPONSE_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140966911i32 as _);
pub const PEER_E_IPV6_NOT_INSTALLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995583i32 as _);
pub const PEER_E_MAX_RECORD_SIZE_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140994812i32 as _);
pub const PEER_E_NODE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995320i32 as _);
pub const PEER_E_NOT_AUTHORIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987360i32 as _);
pub const PEER_E_NOT_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995582i32 as _);
pub const PEER_E_NOT_LICENSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995580i32 as _);
pub const PEER_E_NOT_SIGNED_IN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140966909i32 as _);
pub const PEER_E_NO_CLOUD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140991487i32 as _);
pub const PEER_E_NO_KEY_ACCESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995069i32 as _);
pub const PEER_E_NO_MEMBERS_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987244i32 as _);
pub const PEER_E_NO_MEMBER_CONNECTIONS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987243i32 as _);
pub const PEER_E_NO_MORE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140979197i32 as _);
pub const PEER_E_PASSWORD_DOES_NOT_MEET_POLICY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987359i32 as _);
pub const PEER_E_PNRP_DUPLICATE_PEER_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140979195i32 as _);
pub const PEER_E_PRIVACY_DECLINED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140966908i32 as _);
pub const PEER_E_RECORD_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140994815i32 as _);
pub const PEER_E_SERVICE_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987231i32 as _);
pub const PEER_E_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140966907i32 as _);
pub const PEER_E_TOO_MANY_ATTRIBUTES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995561i32 as _);
pub const PEER_E_TOO_MANY_IDENTITIES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140995070i32 as _);
pub const PEER_E_UNABLE_TO_LISTEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987242i32 as _);
pub const PEER_E_UNSUPPORTED_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140987248i32 as _);
pub const PEER_S_ALREADY_A_MEMBER: ::windows::core::HRESULT = ::windows::core::HRESULT(6488070i32 as _);
pub const PEER_S_ALREADY_CONNECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(6496256i32 as _);
pub const PEER_S_GRAPH_DATA_CREATED: ::windows::core::HRESULT = ::windows::core::HRESULT(6488065i32 as _);
pub const PEER_S_NO_CONNECTIVITY: ::windows::core::HRESULT = ::windows::core::HRESULT(6488069i32 as _);
pub const PEER_S_NO_EVENT_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(6488066i32 as _);
pub const PEER_S_SUBSCRIPTION_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(6512640i32 as _);
pub const PERSIST_E_NOTSELFSIZING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762741i32 as _);
pub const PERSIST_E_SIZEDEFINITE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762743i32 as _);
pub const PERSIST_E_SIZEINDEFINITE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762742i32 as _);
pub const PLA_E_CABAPI_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337645i32 as _);
pub const PLA_E_CONFLICT_INCL_EXCL_API: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337659i32 as _);
pub const PLA_E_CREDENTIALS_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337661i32 as _);
pub const PLA_E_DCS_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337737i32 as _);
pub const PLA_E_DCS_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337750i32 as _);
pub const PLA_E_DCS_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337918i32 as _);
pub const PLA_E_DCS_NOT_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337660i32 as _);
pub const PLA_E_DCS_SINGLETON_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337662i32 as _);
pub const PLA_E_DCS_START_WAIT_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337654i32 as _);
pub const PLA_E_DC_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337655i32 as _);
pub const PLA_E_DC_START_WAIT_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337653i32 as _);
pub const PLA_E_EXE_ALREADY_CONFIGURED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337657i32 as _);
pub const PLA_E_EXE_FULL_PATH_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337650i32 as _);
pub const PLA_E_EXE_PATH_NOT_VALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337656i32 as _);
pub const PLA_E_INVALID_SESSION_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337649i32 as _);
pub const PLA_E_NETWORK_EXE_NOT_VALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337658i32 as _);
pub const PLA_E_NO_DUPLICATES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337651i32 as _);
pub const PLA_E_NO_MIN_DISK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337808i32 as _);
pub const PLA_E_PLA_CHANNEL_NOT_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337648i32 as _);
pub const PLA_E_PROPERTY_CONFLICT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337663i32 as _);
pub const PLA_E_REPORT_WAIT_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337652i32 as _);
pub const PLA_E_RULES_MANAGER_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337646i32 as _);
pub const PLA_E_TASKSCHED_CHANNEL_NOT_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337647i32 as _);
pub const PLA_E_TOO_MANY_FOLDERS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144337851i32 as _);
pub const PLA_S_PROPERTY_IGNORED: ::windows::core::HRESULT = ::windows::core::HRESULT(3145984i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct POINT {
pub x: i32,
pub y: i32,
}
impl POINT {}
impl ::core::default::Default for POINT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for POINT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("POINT").field("x", &self.x).field("y", &self.y).finish()
}
}
impl ::core::cmp::PartialEq for POINT {
fn eq(&self, other: &Self) -> bool {
self.x == other.x && self.y == other.y
}
}
impl ::core::cmp::Eq for POINT {}
unsafe impl ::windows::core::Abi for POINT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct POINTL {
pub x: i32,
pub y: i32,
}
impl POINTL {}
impl ::core::default::Default for POINTL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for POINTL {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("POINTL").field("x", &self.x).field("y", &self.y).finish()
}
}
impl ::core::cmp::PartialEq for POINTL {
fn eq(&self, other: &Self) -> bool {
self.x == other.x && self.y == other.y
}
}
impl ::core::cmp::Eq for POINTL {}
unsafe impl ::windows::core::Abi for POINTL {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct POINTS {
pub x: i16,
pub y: i16,
}
impl POINTS {}
impl ::core::default::Default for POINTS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for POINTS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("POINTS").field("x", &self.x).field("y", &self.y).finish()
}
}
impl ::core::cmp::PartialEq for POINTS {
fn eq(&self, other: &Self) -> bool {
self.x == other.x && self.y == other.y
}
}
impl ::core::cmp::Eq for POINTS {}
unsafe impl ::windows::core::Abi for POINTS {
type Abi = Self;
}
pub const PRESENTATION_ERROR_LOST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2004811775i32 as _);
pub type PROC = unsafe extern "system" fn() -> isize;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct PSID(pub isize);
impl ::core::default::Default for PSID {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
unsafe impl ::windows::core::Handle for PSID {}
unsafe impl ::windows::core::Abi for PSID {
type Abi = Self;
}
pub const PSINK_E_INDEX_ONLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215471i32 as _);
pub const PSINK_E_LARGE_ATTACHMENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215470i32 as _);
pub const PSINK_E_QUERY_ONLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215472i32 as _);
pub const PSINK_S_LARGE_WORD: ::windows::core::HRESULT = ::windows::core::HRESULT(268179i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct PSTR(pub *mut u8);
impl PSTR {
pub fn is_null(&self) -> bool {
self.0.is_null()
}
}
impl ::core::default::Default for PSTR {
fn default() -> Self {
Self(::core::ptr::null_mut())
}
}
unsafe impl ::windows::core::Abi for PSTR {
type Abi = Self;
#[cfg(feature = "alloc")]
unsafe fn drop_param(param: &mut ::windows::core::Param<'_, Self>) {
if let ::windows::core::Param::Boxed(value) = param {
if !value.is_null() {
unsafe {
::windows::core::alloc::boxed::Box::from_raw(value.0);
}
}
}
}
}
#[cfg(feature = "alloc")]
impl<'a> ::windows::core::IntoParam<'a, PSTR> for &str {
fn into_param(self) -> ::windows::core::Param<'a, PSTR> {
::windows::core::Param::Boxed(PSTR(::windows::core::alloc::boxed::Box::<[u8]>::into_raw(self.bytes().chain(::core::iter::once(0)).collect::<::windows::core::alloc::vec::Vec<u8>>().into_boxed_slice()) as _))
}
}
#[cfg(feature = "alloc")]
impl<'a> ::windows::core::IntoParam<'a, PSTR> for ::windows::core::alloc::string::String {
fn into_param(self) -> ::windows::core::Param<'a, PSTR> {
::windows::core::IntoParam::into_param(self.as_str())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct PWSTR(pub *mut u16);
impl PWSTR {
pub fn is_null(&self) -> bool {
self.0.is_null()
}
}
impl ::core::default::Default for PWSTR {
fn default() -> Self {
Self(::core::ptr::null_mut())
}
}
unsafe impl ::windows::core::Abi for PWSTR {
type Abi = Self;
#[cfg(feature = "alloc")]
unsafe fn drop_param(param: &mut ::windows::core::Param<'_, Self>) {
if let ::windows::core::Param::Boxed(value) = param {
if !value.is_null() {
unsafe {
::windows::core::alloc::boxed::Box::from_raw(value.0);
}
}
}
}
}
#[cfg(feature = "alloc")]
impl<'a> ::windows::core::IntoParam<'a, PWSTR> for &str {
fn into_param(self) -> ::windows::core::Param<'a, PWSTR> {
::windows::core::Param::Boxed(PWSTR(::windows::core::alloc::boxed::Box::<[u16]>::into_raw(self.encode_utf16().chain(::core::iter::once(0)).collect::<::windows::core::alloc::vec::Vec<u16>>().into_boxed_slice()) as _))
}
}
#[cfg(feature = "alloc")]
impl<'a> ::windows::core::IntoParam<'a, PWSTR> for ::windows::core::alloc::string::String {
fn into_param(self) -> ::windows::core::Param<'a, PWSTR> {
::windows::core::IntoParam::into_param(self.as_str())
}
}
#[cfg(feature = "std")]
impl<'a> ::windows::core::IntoParam<'a, PWSTR> for &::std::ffi::OsStr {
fn into_param(self) -> ::windows::core::Param<'a, PWSTR> {
use std::os::windows::ffi::OsStrExt;
::windows::core::Param::Boxed(PWSTR(::windows::core::alloc::boxed::Box::<[u16]>::into_raw(self.encode_wide().chain(::core::iter::once(0)).collect::<::windows::core::alloc::vec::Vec<u16>>().into_boxed_slice()) as _))
}
}
#[cfg(feature = "std")]
impl<'a> ::windows::core::IntoParam<'a, PWSTR> for ::std::ffi::OsString {
fn into_param(self) -> ::windows::core::Param<'a, PWSTR> {
::windows::core::IntoParam::into_param(self.as_os_str())
}
}
pub const QPARSE_E_EXPECTING_BRACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215770i32 as _);
pub const QPARSE_E_EXPECTING_COMMA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215759i32 as _);
pub const QPARSE_E_EXPECTING_CURRENCY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215772i32 as _);
pub const QPARSE_E_EXPECTING_DATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215773i32 as _);
pub const QPARSE_E_EXPECTING_EOS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215760i32 as _);
pub const QPARSE_E_EXPECTING_GUID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215771i32 as _);
pub const QPARSE_E_EXPECTING_INTEGER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215775i32 as _);
pub const QPARSE_E_EXPECTING_PAREN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215769i32 as _);
pub const QPARSE_E_EXPECTING_PHRASE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215766i32 as _);
pub const QPARSE_E_EXPECTING_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215768i32 as _);
pub const QPARSE_E_EXPECTING_REAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215774i32 as _);
pub const QPARSE_E_EXPECTING_REGEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215764i32 as _);
pub const QPARSE_E_EXPECTING_REGEX_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215763i32 as _);
pub const QPARSE_E_INVALID_GROUPING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215753i32 as _);
pub const QPARSE_E_INVALID_LITERAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215762i32 as _);
pub const QPARSE_E_INVALID_QUERY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215750i32 as _);
pub const QPARSE_E_INVALID_RANKMETHOD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215749i32 as _);
pub const QPARSE_E_INVALID_SORT_ORDER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215755i32 as _);
pub const QPARSE_E_NOT_YET_IMPLEMENTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215767i32 as _);
pub const QPARSE_E_NO_SUCH_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215761i32 as _);
pub const QPARSE_E_NO_SUCH_SORT_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215756i32 as _);
pub const QPARSE_E_UNEXPECTED_EOS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215758i32 as _);
pub const QPARSE_E_UNEXPECTED_NOT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215776i32 as _);
pub const QPARSE_E_UNSUPPORTED_PROPERTY_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215765i32 as _);
pub const QPARSE_E_WEIGHT_OUT_OF_RANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215757i32 as _);
pub const QPLIST_E_BAD_GUID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215783i32 as _);
pub const QPLIST_E_BYREF_USED_WITHOUT_PTRTYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215778i32 as _);
pub const QPLIST_E_CANT_OPEN_FILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215791i32 as _);
pub const QPLIST_E_CANT_SET_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215781i32 as _);
pub const QPLIST_E_DUPLICATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215780i32 as _);
pub const QPLIST_E_EXPECTING_CLOSE_PAREN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215785i32 as _);
pub const QPLIST_E_EXPECTING_GUID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215784i32 as _);
pub const QPLIST_E_EXPECTING_INTEGER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215786i32 as _);
pub const QPLIST_E_EXPECTING_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215789i32 as _);
pub const QPLIST_E_EXPECTING_PROP_SPEC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215782i32 as _);
pub const QPLIST_E_EXPECTING_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215788i32 as _);
pub const QPLIST_E_READ_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215790i32 as _);
pub const QPLIST_E_UNRECOGNIZED_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215787i32 as _);
pub const QPLIST_E_VECTORBYREF_USED_ALONE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215779i32 as _);
pub const QPLIST_S_DUPLICATE: ::windows::core::HRESULT = ::windows::core::HRESULT(267897i32 as _);
pub const QUERY_E_ALLNOISE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215867i32 as _);
pub const QUERY_E_DIR_ON_REMOVABLE_DRIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215861i32 as _);
pub const QUERY_E_DUPLICATE_OUTPUT_COLUMN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215864i32 as _);
pub const QUERY_E_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215872i32 as _);
pub const QUERY_E_INVALIDCATEGORIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215868i32 as _);
pub const QUERY_E_INVALIDQUERY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215871i32 as _);
pub const QUERY_E_INVALIDRESTRICTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215870i32 as _);
pub const QUERY_E_INVALIDSORT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215869i32 as _);
pub const QUERY_E_INVALID_DIRECTORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215862i32 as _);
pub const QUERY_E_INVALID_OUTPUT_COLUMN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215863i32 as _);
pub const QUERY_E_TIMEDOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215865i32 as _);
pub const QUERY_E_TOOCOMPLEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215866i32 as _);
pub const QUERY_S_NO_QUERY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215860i32 as _);
pub const QUTIL_E_CANT_CONVERT_VROOT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215754i32 as _);
pub const QUTIL_E_INVALID_CODEPAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1073473928i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct RECT {
pub left: i32,
pub top: i32,
pub right: i32,
pub bottom: i32,
}
impl RECT {}
impl ::core::default::Default for RECT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for RECT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("RECT").field("left", &self.left).field("top", &self.top).field("right", &self.right).field("bottom", &self.bottom).finish()
}
}
impl ::core::cmp::PartialEq for RECT {
fn eq(&self, other: &Self) -> bool {
self.left == other.left && self.top == other.top && self.right == other.right && self.bottom == other.bottom
}
}
impl ::core::cmp::Eq for RECT {}
unsafe impl ::windows::core::Abi for RECT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct RECTL {
pub left: i32,
pub top: i32,
pub right: i32,
pub bottom: i32,
}
impl RECTL {}
impl ::core::default::Default for RECTL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for RECTL {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("RECTL").field("left", &self.left).field("top", &self.top).field("right", &self.right).field("bottom", &self.bottom).finish()
}
}
impl ::core::cmp::PartialEq for RECTL {
fn eq(&self, other: &Self) -> bool {
self.left == other.left && self.top == other.top && self.right == other.right && self.bottom == other.bottom
}
}
impl ::core::cmp::Eq for RECTL {}
unsafe impl ::windows::core::Abi for RECTL {
type Abi = Self;
}
pub const REGDB_E_BADTHREADINGMODEL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221162i32 as _);
pub const REGDB_E_CLASSNOTREG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221164i32 as _);
pub const REGDB_E_FIRST: i32 = -2147221168i32;
pub const REGDB_E_IIDNOTREG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221163i32 as _);
pub const REGDB_E_INVALIDVALUE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221165i32 as _);
pub const REGDB_E_KEYMISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221166i32 as _);
pub const REGDB_E_LAST: i32 = -2147221153i32;
pub const REGDB_E_PACKAGEPOLICYVIOLATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221161i32 as _);
pub const REGDB_E_READREGDB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221168i32 as _);
pub const REGDB_E_WRITEREGDB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221167i32 as _);
pub const REGDB_S_FIRST: i32 = 262480i32;
pub const REGDB_S_LAST: i32 = 262495i32;
pub const ROUTEBASE: u32 = 900u32;
pub const ROUTEBASEEND: u32 = 957u32;
pub const RO_E_BLOCKED_CROSS_ASTA_CALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483617i32 as _);
pub const RO_E_CANNOT_ACTIVATE_FULL_TRUST_SERVER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483616i32 as _);
pub const RO_E_CANNOT_ACTIVATE_UNIVERSAL_APPLICATION_SERVER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483615i32 as _);
pub const RO_E_CHANGE_NOTIFICATION_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483627i32 as _);
pub const RO_E_CLOSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483629i32 as _);
pub const RO_E_COMMITTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483618i32 as _);
pub const RO_E_ERROR_STRING_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483626i32 as _);
pub const RO_E_EXCLUSIVE_WRITE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483628i32 as _);
pub const RO_E_INVALID_METADATA_FILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483630i32 as _);
pub const RO_E_METADATA_INVALID_TYPE_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483631i32 as _);
pub const RO_E_METADATA_NAME_IS_NAMESPACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483632i32 as _);
pub const RO_E_METADATA_NAME_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483633i32 as _);
pub const RO_E_MUST_BE_AGILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483620i32 as _);
pub const RO_E_UNSUPPORTED_FROM_MTA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147483619i32 as _);
pub const RPC_E_ACCESS_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417829i32 as _);
pub const RPC_E_ATTEMPTED_MULTITHREAD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417854i32 as _);
pub const RPC_E_CALL_CANCELED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418110i32 as _);
pub const RPC_E_CALL_COMPLETE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417833i32 as _);
pub const RPC_E_CALL_REJECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418111i32 as _);
pub const RPC_E_CANTCALLOUT_AGAIN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418095i32 as _);
pub const RPC_E_CANTCALLOUT_INASYNCCALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418108i32 as _);
pub const RPC_E_CANTCALLOUT_INEXTERNALCALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418107i32 as _);
pub const RPC_E_CANTCALLOUT_ININPUTSYNCCALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417843i32 as _);
pub const RPC_E_CANTPOST_INSENDCALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418109i32 as _);
pub const RPC_E_CANTTRANSMIT_CALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418102i32 as _);
pub const RPC_E_CHANGED_MODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417850i32 as _);
pub const RPC_E_CLIENT_CANTMARSHAL_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418101i32 as _);
pub const RPC_E_CLIENT_CANTUNMARSHAL_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418100i32 as _);
pub const RPC_E_CLIENT_DIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418104i32 as _);
pub const RPC_E_CONNECTION_TERMINATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418106i32 as _);
pub const RPC_E_DISCONNECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417848i32 as _);
pub const RPC_E_FAULT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417852i32 as _);
pub const RPC_E_FULLSIC_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417823i32 as _);
pub const RPC_E_INVALIDMETHOD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417849i32 as _);
pub const RPC_E_INVALID_CALLDATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417844i32 as _);
pub const RPC_E_INVALID_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418097i32 as _);
pub const RPC_E_INVALID_DATAPACKET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418103i32 as _);
pub const RPC_E_INVALID_EXTENSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417838i32 as _);
pub const RPC_E_INVALID_HEADER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417839i32 as _);
pub const RPC_E_INVALID_IPID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417837i32 as _);
pub const RPC_E_INVALID_OBJECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417836i32 as _);
pub const RPC_E_INVALID_OBJREF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417827i32 as _);
pub const RPC_E_INVALID_PARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418096i32 as _);
pub const RPC_E_INVALID_STD_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417822i32 as _);
pub const RPC_E_NOT_REGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417853i32 as _);
pub const RPC_E_NO_CONTEXT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417826i32 as _);
pub const RPC_E_NO_GOOD_SECURITY_PACKAGES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417830i32 as _);
pub const RPC_E_NO_SYNC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417824i32 as _);
pub const RPC_E_OUT_OF_RESOURCES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417855i32 as _);
pub const RPC_E_REMOTE_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417828i32 as _);
pub const RPC_E_RETRY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417847i32 as _);
pub const RPC_E_SERVERCALL_REJECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417845i32 as _);
pub const RPC_E_SERVERCALL_RETRYLATER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417846i32 as _);
pub const RPC_E_SERVERFAULT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417851i32 as _);
pub const RPC_E_SERVER_CANTMARSHAL_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418099i32 as _);
pub const RPC_E_SERVER_CANTUNMARSHAL_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418098i32 as _);
pub const RPC_E_SERVER_DIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418105i32 as _);
pub const RPC_E_SERVER_DIED_DNE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147418094i32 as _);
pub const RPC_E_SYS_CALL_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417856i32 as _);
pub const RPC_E_THREAD_NOT_INIT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417841i32 as _);
pub const RPC_E_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417825i32 as _);
pub const RPC_E_TOO_LATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417831i32 as _);
pub const RPC_E_UNEXPECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147352577i32 as _);
pub const RPC_E_UNSECURE_CALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417832i32 as _);
pub const RPC_E_VERSION_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417840i32 as _);
pub const RPC_E_WRONG_THREAD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417842i32 as _);
pub const RPC_NT_ADDRESS_ERROR: NTSTATUS = NTSTATUS(-1073610683i32 as _);
pub const RPC_NT_ALREADY_LISTENING: NTSTATUS = NTSTATUS(-1073610738i32 as _);
pub const RPC_NT_ALREADY_REGISTERED: NTSTATUS = NTSTATUS(-1073610740i32 as _);
pub const RPC_NT_BAD_STUB_DATA: NTSTATUS = NTSTATUS(-1073545204i32 as _);
pub const RPC_NT_BINDING_HAS_NO_AUTH: NTSTATUS = NTSTATUS(-1073610705i32 as _);
pub const RPC_NT_BINDING_INCOMPLETE: NTSTATUS = NTSTATUS(-1073610671i32 as _);
pub const RPC_NT_BYTE_COUNT_TOO_SMALL: NTSTATUS = NTSTATUS(-1073545205i32 as _);
pub const RPC_NT_CALL_CANCELLED: NTSTATUS = NTSTATUS(-1073610672i32 as _);
pub const RPC_NT_CALL_FAILED: NTSTATUS = NTSTATUS(-1073610725i32 as _);
pub const RPC_NT_CALL_FAILED_DNE: NTSTATUS = NTSTATUS(-1073610724i32 as _);
pub const RPC_NT_CALL_IN_PROGRESS: NTSTATUS = NTSTATUS(-1073610679i32 as _);
pub const RPC_NT_CANNOT_SUPPORT: NTSTATUS = NTSTATUS(-1073610687i32 as _);
pub const RPC_NT_CANT_CREATE_ENDPOINT: NTSTATUS = NTSTATUS(-1073610731i32 as _);
pub const RPC_NT_COMM_FAILURE: NTSTATUS = NTSTATUS(-1073610670i32 as _);
pub const RPC_NT_COOKIE_AUTH_FAILED: NTSTATUS = NTSTATUS(-1073610651i32 as _);
pub const RPC_NT_DUPLICATE_ENDPOINT: NTSTATUS = NTSTATUS(-1073610711i32 as _);
pub const RPC_NT_ENTRY_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1073610691i32 as _);
pub const RPC_NT_ENTRY_NOT_FOUND: NTSTATUS = NTSTATUS(-1073610690i32 as _);
pub const RPC_NT_ENUM_VALUE_OUT_OF_RANGE: NTSTATUS = NTSTATUS(-1073545206i32 as _);
pub const RPC_NT_FP_DIV_ZERO: NTSTATUS = NTSTATUS(-1073610682i32 as _);
pub const RPC_NT_FP_OVERFLOW: NTSTATUS = NTSTATUS(-1073610680i32 as _);
pub const RPC_NT_FP_UNDERFLOW: NTSTATUS = NTSTATUS(-1073610681i32 as _);
pub const RPC_NT_GROUP_MEMBER_NOT_FOUND: NTSTATUS = NTSTATUS(-1073610677i32 as _);
pub const RPC_NT_INCOMPLETE_NAME: NTSTATUS = NTSTATUS(-1073610696i32 as _);
pub const RPC_NT_INTERFACE_NOT_FOUND: NTSTATUS = NTSTATUS(-1073610692i32 as _);
pub const RPC_NT_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1073610685i32 as _);
pub const RPC_NT_INVALID_ASYNC_CALL: NTSTATUS = NTSTATUS(-1073610653i32 as _);
pub const RPC_NT_INVALID_ASYNC_HANDLE: NTSTATUS = NTSTATUS(-1073610654i32 as _);
pub const RPC_NT_INVALID_AUTH_IDENTITY: NTSTATUS = NTSTATUS(-1073610702i32 as _);
pub const RPC_NT_INVALID_BINDING: NTSTATUS = NTSTATUS(-1073610749i32 as _);
pub const RPC_NT_INVALID_BOUND: NTSTATUS = NTSTATUS(-1073610717i32 as _);
pub const RPC_NT_INVALID_ENDPOINT_FORMAT: NTSTATUS = NTSTATUS(-1073610745i32 as _);
pub const RPC_NT_INVALID_ES_ACTION: NTSTATUS = NTSTATUS(-1073545127i32 as _);
pub const RPC_NT_INVALID_NAF_ID: NTSTATUS = NTSTATUS(-1073610688i32 as _);
pub const RPC_NT_INVALID_NAME_SYNTAX: NTSTATUS = NTSTATUS(-1073610715i32 as _);
pub const RPC_NT_INVALID_NETWORK_OPTIONS: NTSTATUS = NTSTATUS(-1073610727i32 as _);
pub const RPC_NT_INVALID_NET_ADDR: NTSTATUS = NTSTATUS(-1073610744i32 as _);
pub const RPC_NT_INVALID_OBJECT: NTSTATUS = NTSTATUS(-1073610675i32 as _);
pub const RPC_NT_INVALID_PIPE_OBJECT: NTSTATUS = NTSTATUS(-1073545124i32 as _);
pub const RPC_NT_INVALID_PIPE_OPERATION: NTSTATUS = NTSTATUS(-1073545123i32 as _);
pub const RPC_NT_INVALID_RPC_PROTSEQ: NTSTATUS = NTSTATUS(-1073610747i32 as _);
pub const RPC_NT_INVALID_STRING_BINDING: NTSTATUS = NTSTATUS(-1073610751i32 as _);
pub const RPC_NT_INVALID_STRING_UUID: NTSTATUS = NTSTATUS(-1073610746i32 as _);
pub const RPC_NT_INVALID_TAG: NTSTATUS = NTSTATUS(-1073610718i32 as _);
pub const RPC_NT_INVALID_TIMEOUT: NTSTATUS = NTSTATUS(-1073610742i32 as _);
pub const RPC_NT_INVALID_VERS_OPTION: NTSTATUS = NTSTATUS(-1073610695i32 as _);
pub const RPC_NT_MAX_CALLS_TOO_SMALL: NTSTATUS = NTSTATUS(-1073610709i32 as _);
pub const RPC_NT_NAME_SERVICE_UNAVAILABLE: NTSTATUS = NTSTATUS(-1073610689i32 as _);
pub const RPC_NT_NOTHING_TO_EXPORT: NTSTATUS = NTSTATUS(-1073610697i32 as _);
pub const RPC_NT_NOT_ALL_OBJS_UNEXPORTED: NTSTATUS = NTSTATUS(-1073610693i32 as _);
pub const RPC_NT_NOT_CANCELLED: NTSTATUS = NTSTATUS(-1073610664i32 as _);
pub const RPC_NT_NOT_LISTENING: NTSTATUS = NTSTATUS(-1073610736i32 as _);
pub const RPC_NT_NOT_RPC_ERROR: NTSTATUS = NTSTATUS(-1073610667i32 as _);
pub const RPC_NT_NO_BINDINGS: NTSTATUS = NTSTATUS(-1073610733i32 as _);
pub const RPC_NT_NO_CALL_ACTIVE: NTSTATUS = NTSTATUS(-1073610726i32 as _);
pub const RPC_NT_NO_CONTEXT_AVAILABLE: NTSTATUS = NTSTATUS(-1073610686i32 as _);
pub const RPC_NT_NO_ENDPOINT_FOUND: NTSTATUS = NTSTATUS(-1073610743i32 as _);
pub const RPC_NT_NO_ENTRY_NAME: NTSTATUS = NTSTATUS(-1073610716i32 as _);
pub const RPC_NT_NO_INTERFACES: NTSTATUS = NTSTATUS(-1073610673i32 as _);
pub const RPC_NT_NO_MORE_BINDINGS: NTSTATUS = NTSTATUS(-1073610678i32 as _);
pub const RPC_NT_NO_MORE_ENTRIES: NTSTATUS = NTSTATUS(-1073545215i32 as _);
pub const RPC_NT_NO_MORE_MEMBERS: NTSTATUS = NTSTATUS(-1073610694i32 as _);
pub const RPC_NT_NO_PRINC_NAME: NTSTATUS = NTSTATUS(-1073610668i32 as _);
pub const RPC_NT_NO_PROTSEQS: NTSTATUS = NTSTATUS(-1073610732i32 as _);
pub const RPC_NT_NO_PROTSEQS_REGISTERED: NTSTATUS = NTSTATUS(-1073610737i32 as _);
pub const RPC_NT_NULL_REF_POINTER: NTSTATUS = NTSTATUS(-1073545207i32 as _);
pub const RPC_NT_OBJECT_NOT_FOUND: NTSTATUS = NTSTATUS(-1073610741i32 as _);
pub const RPC_NT_OUT_OF_RESOURCES: NTSTATUS = NTSTATUS(-1073610730i32 as _);
pub const RPC_NT_PIPE_CLOSED: NTSTATUS = NTSTATUS(-1073545121i32 as _);
pub const RPC_NT_PIPE_DISCIPLINE_ERROR: NTSTATUS = NTSTATUS(-1073545120i32 as _);
pub const RPC_NT_PIPE_EMPTY: NTSTATUS = NTSTATUS(-1073545119i32 as _);
pub const RPC_NT_PROCNUM_OUT_OF_RANGE: NTSTATUS = NTSTATUS(-1073610706i32 as _);
pub const RPC_NT_PROTOCOL_ERROR: NTSTATUS = NTSTATUS(-1073610723i32 as _);
pub const RPC_NT_PROTSEQ_NOT_FOUND: NTSTATUS = NTSTATUS(-1073610707i32 as _);
pub const RPC_NT_PROTSEQ_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073610748i32 as _);
pub const RPC_NT_PROXY_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1073610652i32 as _);
pub const RPC_NT_SEC_PKG_ERROR: NTSTATUS = NTSTATUS(-1073610665i32 as _);
pub const RPC_NT_SEND_INCOMPLETE: NTSTATUS = NTSTATUS(1073873071i32 as _);
pub const RPC_NT_SERVER_TOO_BUSY: NTSTATUS = NTSTATUS(-1073610728i32 as _);
pub const RPC_NT_SERVER_UNAVAILABLE: NTSTATUS = NTSTATUS(-1073610729i32 as _);
pub const RPC_NT_SS_CANNOT_GET_CALL_HANDLE: NTSTATUS = NTSTATUS(-1073545208i32 as _);
pub const RPC_NT_SS_CHAR_TRANS_OPEN_FAIL: NTSTATUS = NTSTATUS(-1073545214i32 as _);
pub const RPC_NT_SS_CHAR_TRANS_SHORT_FILE: NTSTATUS = NTSTATUS(-1073545213i32 as _);
pub const RPC_NT_SS_CONTEXT_DAMAGED: NTSTATUS = NTSTATUS(-1073545210i32 as _);
pub const RPC_NT_SS_CONTEXT_MISMATCH: NTSTATUS = NTSTATUS(-1073545211i32 as _);
pub const RPC_NT_SS_HANDLES_MISMATCH: NTSTATUS = NTSTATUS(-1073545209i32 as _);
pub const RPC_NT_SS_IN_NULL_CONTEXT: NTSTATUS = NTSTATUS(-1073545212i32 as _);
pub const RPC_NT_STRING_TOO_LONG: NTSTATUS = NTSTATUS(-1073610708i32 as _);
pub const RPC_NT_TYPE_ALREADY_REGISTERED: NTSTATUS = NTSTATUS(-1073610739i32 as _);
pub const RPC_NT_UNKNOWN_AUTHN_LEVEL: NTSTATUS = NTSTATUS(-1073610703i32 as _);
pub const RPC_NT_UNKNOWN_AUTHN_SERVICE: NTSTATUS = NTSTATUS(-1073610704i32 as _);
pub const RPC_NT_UNKNOWN_AUTHN_TYPE: NTSTATUS = NTSTATUS(-1073610710i32 as _);
pub const RPC_NT_UNKNOWN_AUTHZ_SERVICE: NTSTATUS = NTSTATUS(-1073610701i32 as _);
pub const RPC_NT_UNKNOWN_IF: NTSTATUS = NTSTATUS(-1073610734i32 as _);
pub const RPC_NT_UNKNOWN_MGR_TYPE: NTSTATUS = NTSTATUS(-1073610735i32 as _);
pub const RPC_NT_UNSUPPORTED_AUTHN_LEVEL: NTSTATUS = NTSTATUS(-1073610669i32 as _);
pub const RPC_NT_UNSUPPORTED_NAME_SYNTAX: NTSTATUS = NTSTATUS(-1073610714i32 as _);
pub const RPC_NT_UNSUPPORTED_TRANS_SYN: NTSTATUS = NTSTATUS(-1073610721i32 as _);
pub const RPC_NT_UNSUPPORTED_TYPE: NTSTATUS = NTSTATUS(-1073610719i32 as _);
pub const RPC_NT_UUID_LOCAL_ONLY: NTSTATUS = NTSTATUS(1073872982i32 as _);
pub const RPC_NT_UUID_NO_ADDRESS: NTSTATUS = NTSTATUS(-1073610712i32 as _);
pub const RPC_NT_WRONG_ES_VERSION: NTSTATUS = NTSTATUS(-1073545126i32 as _);
pub const RPC_NT_WRONG_KIND_OF_BINDING: NTSTATUS = NTSTATUS(-1073610750i32 as _);
pub const RPC_NT_WRONG_PIPE_VERSION: NTSTATUS = NTSTATUS(-1073545122i32 as _);
pub const RPC_NT_WRONG_STUB_VERSION: NTSTATUS = NTSTATUS(-1073545125i32 as _);
pub const RPC_NT_ZERO_DIVIDE: NTSTATUS = NTSTATUS(-1073610684i32 as _);
pub const RPC_S_CALLPENDING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417835i32 as _);
pub const RPC_S_WAITONTIMER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147417834i32 as _);
pub const RPC_X_BAD_STUB_DATA: i32 = 1783i32;
pub const RPC_X_BYTE_COUNT_TOO_SMALL: i32 = 1782i32;
pub const RPC_X_ENUM_VALUE_OUT_OF_RANGE: i32 = 1781i32;
pub const RPC_X_INVALID_ES_ACTION: i32 = 1827i32;
pub const RPC_X_INVALID_PIPE_OBJECT: i32 = 1830i32;
pub const RPC_X_NO_MORE_ENTRIES: i32 = 1772i32;
pub const RPC_X_NULL_REF_POINTER: i32 = 1780i32;
pub const RPC_X_PIPE_CLOSED: i32 = 1916i32;
pub const RPC_X_PIPE_DISCIPLINE_ERROR: i32 = 1917i32;
pub const RPC_X_PIPE_EMPTY: i32 = 1918i32;
pub const RPC_X_SS_CANNOT_GET_CALL_HANDLE: i32 = 1779i32;
pub const RPC_X_SS_CHAR_TRANS_OPEN_FAIL: i32 = 1773i32;
pub const RPC_X_SS_CHAR_TRANS_SHORT_FILE: i32 = 1774i32;
pub const RPC_X_SS_CONTEXT_DAMAGED: i32 = 1777i32;
pub const RPC_X_SS_HANDLES_MISMATCH: i32 = 1778i32;
pub const RPC_X_SS_IN_NULL_CONTEXT: i32 = 1775i32;
pub const RPC_X_WRONG_ES_VERSION: i32 = 1828i32;
pub const RPC_X_WRONG_PIPE_ORDER: i32 = 1831i32;
pub const RPC_X_WRONG_PIPE_VERSION: i32 = 1832i32;
pub const RPC_X_WRONG_STUB_VERSION: i32 = 1829i32;
#[inline]
pub unsafe fn RtlNtStatusToDosError<'a, Param0: ::windows::core::IntoParam<'a, NTSTATUS>>(status: Param0) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlNtStatusToDosError(status: NTSTATUS) -> u32;
}
::core::mem::transmute(RtlNtStatusToDosError(status.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const SCARD_E_BAD_SEEK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435031i32 as _);
pub const SCARD_E_CANCELLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435070i32 as _);
pub const SCARD_E_CANT_DISPOSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435058i32 as _);
pub const SCARD_E_CARD_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435044i32 as _);
pub const SCARD_E_CERTIFICATE_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435027i32 as _);
pub const SCARD_E_COMM_DATA_LOST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435025i32 as _);
pub const SCARD_E_DIR_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435037i32 as _);
pub const SCARD_E_DUPLICATE_READER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435045i32 as _);
pub const SCARD_E_FILE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435036i32 as _);
pub const SCARD_E_ICC_CREATEORDER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435039i32 as _);
pub const SCARD_E_ICC_INSTALLATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435040i32 as _);
pub const SCARD_E_INSUFFICIENT_BUFFER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435064i32 as _);
pub const SCARD_E_INVALID_ATR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435051i32 as _);
pub const SCARD_E_INVALID_CHV: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435030i32 as _);
pub const SCARD_E_INVALID_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435069i32 as _);
pub const SCARD_E_INVALID_PARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435068i32 as _);
pub const SCARD_E_INVALID_TARGET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435067i32 as _);
pub const SCARD_E_INVALID_VALUE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435055i32 as _);
pub const SCARD_E_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435056i32 as _);
pub const SCARD_E_NOT_TRANSACTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435050i32 as _);
pub const SCARD_E_NO_ACCESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435033i32 as _);
pub const SCARD_E_NO_DIR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435035i32 as _);
pub const SCARD_E_NO_FILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435034i32 as _);
pub const SCARD_E_NO_KEY_CONTAINER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435024i32 as _);
pub const SCARD_E_NO_MEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435066i32 as _);
pub const SCARD_E_NO_PIN_CACHE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435021i32 as _);
pub const SCARD_E_NO_READERS_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435026i32 as _);
pub const SCARD_E_NO_SERVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435043i32 as _);
pub const SCARD_E_NO_SMARTCARD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435060i32 as _);
pub const SCARD_E_NO_SUCH_CERTIFICATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435028i32 as _);
pub const SCARD_E_PCI_TOO_SMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435047i32 as _);
pub const SCARD_E_PIN_CACHE_EXPIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435022i32 as _);
pub const SCARD_E_PROTO_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435057i32 as _);
pub const SCARD_E_READER_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435049i32 as _);
pub const SCARD_E_READER_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435046i32 as _);
pub const SCARD_E_READ_ONLY_CARD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435020i32 as _);
pub const SCARD_E_SERVER_TOO_BUSY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435023i32 as _);
pub const SCARD_E_SERVICE_STOPPED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435042i32 as _);
pub const SCARD_E_SHARING_VIOLATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435061i32 as _);
pub const SCARD_E_SYSTEM_CANCELLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435054i32 as _);
pub const SCARD_E_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435062i32 as _);
pub const SCARD_E_UNEXPECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435041i32 as _);
pub const SCARD_E_UNKNOWN_CARD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435059i32 as _);
pub const SCARD_E_UNKNOWN_READER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435063i32 as _);
pub const SCARD_E_UNKNOWN_RES_MNG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435029i32 as _);
pub const SCARD_E_UNSUPPORTED_FEATURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435038i32 as _);
pub const SCARD_E_WRITE_TOO_MANY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435032i32 as _);
pub const SCARD_F_COMM_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435053i32 as _);
pub const SCARD_F_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435071i32 as _);
pub const SCARD_F_UNKNOWN_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435052i32 as _);
pub const SCARD_F_WAITED_TOO_LONG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435065i32 as _);
pub const SCARD_P_SHUTDOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146435048i32 as _);
pub const SCARD_W_CACHE_ITEM_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434960i32 as _);
pub const SCARD_W_CACHE_ITEM_STALE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434959i32 as _);
pub const SCARD_W_CACHE_ITEM_TOO_BIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434958i32 as _);
pub const SCARD_W_CANCELLED_BY_USER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434962i32 as _);
pub const SCARD_W_CARD_NOT_AUTHENTICATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434961i32 as _);
pub const SCARD_W_CHV_BLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434964i32 as _);
pub const SCARD_W_EOF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434963i32 as _);
pub const SCARD_W_REMOVED_CARD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434967i32 as _);
pub const SCARD_W_RESET_CARD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434968i32 as _);
pub const SCARD_W_SECURITY_VIOLATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434966i32 as _);
pub const SCARD_W_UNPOWERED_CARD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434969i32 as _);
pub const SCARD_W_UNRESPONSIVE_CARD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434970i32 as _);
pub const SCARD_W_UNSUPPORTED_CARD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434971i32 as _);
pub const SCARD_W_WRONG_CHV: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146434965i32 as _);
pub const SCHED_E_ACCOUNT_DBASE_CORRUPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216623i32 as _);
pub const SCHED_E_ACCOUNT_INFORMATION_NOT_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216625i32 as _);
pub const SCHED_E_ACCOUNT_NAME_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216624i32 as _);
pub const SCHED_E_ALREADY_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216609i32 as _);
pub const SCHED_E_CANNOT_OPEN_TASK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216627i32 as _);
pub const SCHED_E_DEPRECATED_FEATURE_USED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216592i32 as _);
pub const SCHED_E_INVALIDVALUE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216616i32 as _);
pub const SCHED_E_INVALID_TASK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216626i32 as _);
pub const SCHED_E_INVALID_TASK_HASH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216607i32 as _);
pub const SCHED_E_MALFORMEDXML: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216614i32 as _);
pub const SCHED_E_MISSINGNODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216615i32 as _);
pub const SCHED_E_NAMESPACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216617i32 as _);
pub const SCHED_E_NO_SECURITY_SERVICES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216622i32 as _);
pub const SCHED_E_PAST_END_BOUNDARY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216610i32 as _);
pub const SCHED_E_SERVICE_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216606i32 as _);
pub const SCHED_E_SERVICE_NOT_INSTALLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216628i32 as _);
pub const SCHED_E_SERVICE_NOT_LOCALSYSTEM: i32 = 6200i32;
pub const SCHED_E_SERVICE_NOT_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216619i32 as _);
pub const SCHED_E_SERVICE_TOO_BUSY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216605i32 as _);
pub const SCHED_E_START_ON_DEMAND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216600i32 as _);
pub const SCHED_E_TASK_ATTEMPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216604i32 as _);
pub const SCHED_E_TASK_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216602i32 as _);
pub const SCHED_E_TASK_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216630i32 as _);
pub const SCHED_E_TASK_NOT_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216629i32 as _);
pub const SCHED_E_TASK_NOT_UBPM_COMPAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216599i32 as _);
pub const SCHED_E_TASK_NOT_V1_COMPAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216601i32 as _);
pub const SCHED_E_TOO_MANY_NODES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216611i32 as _);
pub const SCHED_E_TRIGGER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216631i32 as _);
pub const SCHED_E_UNEXPECTEDNODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216618i32 as _);
pub const SCHED_E_UNKNOWN_OBJECT_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216621i32 as _);
pub const SCHED_E_UNSUPPORTED_ACCOUNT_OPTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216620i32 as _);
pub const SCHED_E_USER_NOT_LOGGED_ON: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147216608i32 as _);
pub const SCHED_S_BATCH_LOGON_PROBLEM: ::windows::core::HRESULT = ::windows::core::HRESULT(267036i32 as _);
pub const SCHED_S_EVENT_TRIGGER: ::windows::core::HRESULT = ::windows::core::HRESULT(267016i32 as _);
pub const SCHED_S_SOME_TRIGGERS_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(267035i32 as _);
pub const SCHED_S_TASK_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(267010i32 as _);
pub const SCHED_S_TASK_HAS_NOT_RUN: ::windows::core::HRESULT = ::windows::core::HRESULT(267011i32 as _);
pub const SCHED_S_TASK_NOT_SCHEDULED: ::windows::core::HRESULT = ::windows::core::HRESULT(267013i32 as _);
pub const SCHED_S_TASK_NO_MORE_RUNS: ::windows::core::HRESULT = ::windows::core::HRESULT(267012i32 as _);
pub const SCHED_S_TASK_NO_VALID_TRIGGERS: ::windows::core::HRESULT = ::windows::core::HRESULT(267015i32 as _);
pub const SCHED_S_TASK_QUEUED: ::windows::core::HRESULT = ::windows::core::HRESULT(267045i32 as _);
pub const SCHED_S_TASK_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(267008i32 as _);
pub const SCHED_S_TASK_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(267009i32 as _);
pub const SCHED_S_TASK_TERMINATED: ::windows::core::HRESULT = ::windows::core::HRESULT(267014i32 as _);
pub const SDIAG_E_CANCELLED: i32 = -2143551232i32;
pub const SDIAG_E_CANNOTRUN: i32 = -2143551224i32;
pub const SDIAG_E_DISABLED: i32 = -2143551226i32;
pub const SDIAG_E_MANAGEDHOST: i32 = -2143551229i32;
pub const SDIAG_E_NOVERIFIER: i32 = -2143551228i32;
pub const SDIAG_E_POWERSHELL: i32 = -2143551230i32;
pub const SDIAG_E_RESOURCE: i32 = -2143551222i32;
pub const SDIAG_E_ROOTCAUSE: i32 = -2143551221i32;
pub const SDIAG_E_SCRIPT: i32 = -2143551231i32;
pub const SDIAG_E_TRUST: i32 = -2143551225i32;
pub const SDIAG_E_VERSION: i32 = -2143551223i32;
pub const SDIAG_S_CANNOTRUN: i32 = 3932421i32;
pub const SEARCH_E_NOMONIKER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215711i32 as _);
pub const SEARCH_E_NOREGION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215710i32 as _);
pub const SEARCH_S_NOMOREHITS: ::windows::core::HRESULT = ::windows::core::HRESULT(267936i32 as _);
pub const SEC_E_ALGORITHM_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893007i32 as _);
pub const SEC_E_APPLICATION_PROTOCOL_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892953i32 as _);
pub const SEC_E_BAD_BINDINGS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892986i32 as _);
pub const SEC_E_BAD_PKGID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893034i32 as _);
pub const SEC_E_BUFFER_TOO_SMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893023i32 as _);
pub const SEC_E_CANNOT_INSTALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893049i32 as _);
pub const SEC_E_CANNOT_PACK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893047i32 as _);
pub const SEC_E_CERT_EXPIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893016i32 as _);
pub const SEC_E_CERT_UNKNOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893017i32 as _);
pub const SEC_E_CERT_WRONG_USAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892983i32 as _);
pub const SEC_E_CONTEXT_EXPIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893033i32 as _);
pub const SEC_E_CROSSREALM_DELEGATION_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892969i32 as _);
pub const SEC_E_CRYPTO_SYSTEM_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893001i32 as _);
pub const SEC_E_DECRYPT_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893008i32 as _);
pub const SEC_E_DELEGATION_POLICY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892962i32 as _);
pub const SEC_E_DELEGATION_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892987i32 as _);
pub const SEC_E_DOWNGRADE_DETECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892976i32 as _);
pub const SEC_E_ENCRYPT_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893015i32 as _);
pub const SEC_E_EXT_BUFFER_TOO_SMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892950i32 as _);
pub const SEC_E_ILLEGAL_MESSAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893018i32 as _);
pub const SEC_E_INCOMPLETE_CREDENTIALS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893024i32 as _);
pub const SEC_E_INCOMPLETE_MESSAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893032i32 as _);
pub const SEC_E_INSUFFICIENT_BUFFERS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892949i32 as _);
pub const SEC_E_INSUFFICIENT_MEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893056i32 as _);
pub const SEC_E_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893052i32 as _);
pub const SEC_E_INVALID_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893055i32 as _);
pub const SEC_E_INVALID_PARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892963i32 as _);
pub const SEC_E_INVALID_TOKEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893048i32 as _);
pub const SEC_E_INVALID_UPN_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892951i32 as _);
pub const SEC_E_ISSUING_CA_UNTRUSTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892974i32 as _);
pub const SEC_E_ISSUING_CA_UNTRUSTED_KDC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892967i32 as _);
pub const SEC_E_KDC_CERT_EXPIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892966i32 as _);
pub const SEC_E_KDC_CERT_REVOKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892965i32 as _);
pub const SEC_E_KDC_INVALID_REQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892992i32 as _);
pub const SEC_E_KDC_UNABLE_TO_REFER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892991i32 as _);
pub const SEC_E_KDC_UNKNOWN_ETYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892990i32 as _);
pub const SEC_E_LOGON_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893044i32 as _);
pub const SEC_E_MAX_REFERRALS_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893000i32 as _);
pub const SEC_E_MESSAGE_ALTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893041i32 as _);
pub const SEC_E_MULTIPLE_ACCOUNTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892985i32 as _);
pub const SEC_E_MUST_BE_KDC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892999i32 as _);
pub const SEC_E_MUTUAL_AUTH_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892957i32 as _);
pub const SEC_E_NOT_OWNER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893050i32 as _);
pub const SEC_E_NOT_SUPPORTED: i32 = -2146893054i32;
pub const SEC_E_NO_AUTHENTICATING_AUTHORITY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893039i32 as _);
pub const SEC_E_NO_CONTEXT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892959i32 as _);
pub const SEC_E_NO_CREDENTIALS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893042i32 as _);
pub const SEC_E_NO_IMPERSONATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893045i32 as _);
pub const SEC_E_NO_IP_ADDRESSES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893003i32 as _);
pub const SEC_E_NO_KERB_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892984i32 as _);
pub const SEC_E_NO_PA_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892996i32 as _);
pub const SEC_E_NO_S4U_PROT_SUPPORT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892970i32 as _);
pub const SEC_E_NO_SPM: i32 = -2146893052i32;
pub const SEC_E_NO_TGT_REPLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893004i32 as _);
pub const SEC_E_OK: ::windows::core::HRESULT = ::windows::core::HRESULT(0i32 as _);
pub const SEC_E_ONLY_HTTPS_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892955i32 as _);
pub const SEC_E_OUT_OF_SEQUENCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893040i32 as _);
pub const SEC_E_PKINIT_CLIENT_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892972i32 as _);
pub const SEC_E_PKINIT_NAME_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892995i32 as _);
pub const SEC_E_PKU2U_CERT_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892958i32 as _);
pub const SEC_E_POLICY_NLTM_ONLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892961i32 as _);
pub const SEC_E_QOP_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893046i32 as _);
pub const SEC_E_REVOCATION_OFFLINE_C: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892973i32 as _);
pub const SEC_E_REVOCATION_OFFLINE_KDC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892968i32 as _);
pub const SEC_E_SECPKG_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893051i32 as _);
pub const SEC_E_SECURITY_QOS_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893006i32 as _);
pub const SEC_E_SHUTDOWN_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892993i32 as _);
pub const SEC_E_SMARTCARD_CERT_EXPIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892971i32 as _);
pub const SEC_E_SMARTCARD_CERT_REVOKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892975i32 as _);
pub const SEC_E_SMARTCARD_LOGON_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892994i32 as _);
pub const SEC_E_STRONG_CRYPTO_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892998i32 as _);
pub const SEC_E_TARGET_UNKNOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893053i32 as _);
pub const SEC_E_TIME_SKEW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893020i32 as _);
pub const SEC_E_TOO_MANY_PRINCIPALS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892997i32 as _);
pub const SEC_E_UNFINISHED_CONTEXT_DELETED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893005i32 as _);
pub const SEC_E_UNKNOWN_CREDENTIALS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893043i32 as _);
pub const SEC_E_UNSUPPORTED_FUNCTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893054i32 as _);
pub const SEC_E_UNSUPPORTED_PREAUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146892989i32 as _);
pub const SEC_E_UNTRUSTED_ROOT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893019i32 as _);
pub const SEC_E_WRONG_CREDENTIAL_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893002i32 as _);
pub const SEC_E_WRONG_PRINCIPAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146893022i32 as _);
pub const SEC_I_ASYNC_CALL_PENDING: ::windows::core::HRESULT = ::windows::core::HRESULT(590696i32 as _);
pub const SEC_I_COMPLETE_AND_CONTINUE: ::windows::core::HRESULT = ::windows::core::HRESULT(590612i32 as _);
pub const SEC_I_COMPLETE_NEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(590611i32 as _);
pub const SEC_I_CONTEXT_EXPIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(590615i32 as _);
pub const SEC_I_CONTINUE_NEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(590610i32 as _);
pub const SEC_I_CONTINUE_NEEDED_MESSAGE_OK: ::windows::core::HRESULT = ::windows::core::HRESULT(590694i32 as _);
pub const SEC_I_GENERIC_EXTENSION_RECEIVED: ::windows::core::HRESULT = ::windows::core::HRESULT(590614i32 as _);
pub const SEC_I_INCOMPLETE_CREDENTIALS: ::windows::core::HRESULT = ::windows::core::HRESULT(590624i32 as _);
pub const SEC_I_LOCAL_LOGON: ::windows::core::HRESULT = ::windows::core::HRESULT(590613i32 as _);
pub const SEC_I_MESSAGE_FRAGMENT: ::windows::core::HRESULT = ::windows::core::HRESULT(590692i32 as _);
pub const SEC_I_NO_LSA_CONTEXT: ::windows::core::HRESULT = ::windows::core::HRESULT(590627i32 as _);
pub const SEC_I_NO_RENEGOTIATION: ::windows::core::HRESULT = ::windows::core::HRESULT(590688i32 as _);
pub const SEC_I_RENEGOTIATE: ::windows::core::HRESULT = ::windows::core::HRESULT(590625i32 as _);
pub const SEC_I_SIGNATURE_NEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(590684i32 as _);
pub const SEVERITY_ERROR: u32 = 1u32;
pub const SEVERITY_SUCCESS: u32 = 0u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct SHANDLE_PTR(pub isize);
impl ::core::default::Default for SHANDLE_PTR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
unsafe impl ::windows::core::Handle for SHANDLE_PTR {}
unsafe impl ::windows::core::Abi for SHANDLE_PTR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SIZE {
pub cx: i32,
pub cy: i32,
}
impl SIZE {}
impl ::core::default::Default for SIZE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SIZE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SIZE").field("cx", &self.cx).field("cy", &self.cy).finish()
}
}
impl ::core::cmp::PartialEq for SIZE {
fn eq(&self, other: &Self) -> bool {
self.cx == other.cx && self.cy == other.cy
}
}
impl ::core::cmp::Eq for SIZE {}
unsafe impl ::windows::core::Abi for SIZE {
type Abi = Self;
}
pub const SPAPI_E_AUTHENTICODE_DISALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500032i32 as _);
pub const SPAPI_E_AUTHENTICODE_PUBLISHER_NOT_TRUSTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500029i32 as _);
pub const SPAPI_E_AUTHENTICODE_TRUSTED_PUBLISHER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500031i32 as _);
pub const SPAPI_E_AUTHENTICODE_TRUST_NOT_ESTABLISHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500030i32 as _);
pub const SPAPI_E_BAD_INTERFACE_INSTALLSECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500067i32 as _);
pub const SPAPI_E_BAD_SECTION_NAME_LINE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500607i32 as _);
pub const SPAPI_E_BAD_SERVICE_INSTALLSECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500073i32 as _);
pub const SPAPI_E_CANT_LOAD_CLASS_ICON: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500084i32 as _);
pub const SPAPI_E_CANT_REMOVE_DEVINST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500046i32 as _);
pub const SPAPI_E_CLASS_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500095i32 as _);
pub const SPAPI_E_DEVICE_INSTALLER_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500026i32 as _);
pub const SPAPI_E_DEVICE_INSTALL_BLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500024i32 as _);
pub const SPAPI_E_DEVICE_INTERFACE_ACTIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500069i32 as _);
pub const SPAPI_E_DEVICE_INTERFACE_REMOVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500068i32 as _);
pub const SPAPI_E_DEVINFO_DATA_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500077i32 as _);
pub const SPAPI_E_DEVINFO_LIST_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500078i32 as _);
pub const SPAPI_E_DEVINFO_NOT_REGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500088i32 as _);
pub const SPAPI_E_DEVINSTALL_QUEUE_NONNATIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500048i32 as _);
pub const SPAPI_E_DEVINST_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500089i32 as _);
pub const SPAPI_E_DI_BAD_PATH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500076i32 as _);
pub const SPAPI_E_DI_DONT_INSTALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500053i32 as _);
pub const SPAPI_E_DI_DO_DEFAULT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500082i32 as _);
pub const SPAPI_E_DI_FUNCTION_OBSOLETE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500034i32 as _);
pub const SPAPI_E_DI_NOFILECOPY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500081i32 as _);
pub const SPAPI_E_DI_POSTPROCESSING_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500058i32 as _);
pub const SPAPI_E_DRIVER_INSTALL_BLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500023i32 as _);
pub const SPAPI_E_DRIVER_NONNATIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500044i32 as _);
pub const SPAPI_E_DRIVER_STORE_ADD_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500025i32 as _);
pub const SPAPI_E_DRIVER_STORE_DELETE_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500020i32 as _);
pub const SPAPI_E_DUPLICATE_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500094i32 as _);
pub const SPAPI_E_ERROR_NOT_INSTALLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146496512i32 as _);
pub const SPAPI_E_EXPECTED_SECTION_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500608i32 as _);
pub const SPAPI_E_FILEQUEUE_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500074i32 as _);
pub const SPAPI_E_FILE_HASH_NOT_IN_CATALOG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500021i32 as _);
pub const SPAPI_E_GENERAL_SYNTAX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500605i32 as _);
pub const SPAPI_E_INCORRECTLY_COPIED_INF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500041i32 as _);
pub const SPAPI_E_INF_IN_USE_BY_DEVICES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500035i32 as _);
pub const SPAPI_E_INVALID_CLASS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500090i32 as _);
pub const SPAPI_E_INVALID_CLASS_INSTALLER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500083i32 as _);
pub const SPAPI_E_INVALID_COINSTALLER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500057i32 as _);
pub const SPAPI_E_INVALID_DEVINST_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500091i32 as _);
pub const SPAPI_E_INVALID_FILTER_DRIVER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500052i32 as _);
pub const SPAPI_E_INVALID_HWPROFILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500080i32 as _);
pub const SPAPI_E_INVALID_INF_LOGCONFIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500054i32 as _);
pub const SPAPI_E_INVALID_MACHINENAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500064i32 as _);
pub const SPAPI_E_INVALID_PROPPAGE_PROVIDER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500060i32 as _);
pub const SPAPI_E_INVALID_REFERENCE_STRING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500065i32 as _);
pub const SPAPI_E_INVALID_REG_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500087i32 as _);
pub const SPAPI_E_INVALID_TARGET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500045i32 as _);
pub const SPAPI_E_IN_WOW64: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500043i32 as _);
pub const SPAPI_E_KEY_DOES_NOT_EXIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500092i32 as _);
pub const SPAPI_E_LINE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500350i32 as _);
pub const SPAPI_E_MACHINE_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500062i32 as _);
pub const SPAPI_E_NON_WINDOWS_DRIVER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500050i32 as _);
pub const SPAPI_E_NON_WINDOWS_NT_DRIVER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500051i32 as _);
pub const SPAPI_E_NOT_AN_INSTALLED_OEM_INF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500036i32 as _);
pub const SPAPI_E_NOT_DISABLEABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500047i32 as _);
pub const SPAPI_E_NO_ASSOCIATED_CLASS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500096i32 as _);
pub const SPAPI_E_NO_ASSOCIATED_SERVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500071i32 as _);
pub const SPAPI_E_NO_AUTHENTICODE_CATALOG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500033i32 as _);
pub const SPAPI_E_NO_BACKUP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500349i32 as _);
pub const SPAPI_E_NO_CATALOG_FOR_OEM_INF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500049i32 as _);
pub const SPAPI_E_NO_CLASSINSTALL_PARAMS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500075i32 as _);
pub const SPAPI_E_NO_CLASS_DRIVER_LIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500072i32 as _);
pub const SPAPI_E_NO_COMPAT_DRIVERS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500056i32 as _);
pub const SPAPI_E_NO_CONFIGMGR_SERVICES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500061i32 as _);
pub const SPAPI_E_NO_DEFAULT_DEVICE_INTERFACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500070i32 as _);
pub const SPAPI_E_NO_DEVICE_ICON: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500055i32 as _);
pub const SPAPI_E_NO_DEVICE_SELECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500079i32 as _);
pub const SPAPI_E_NO_DRIVER_SELECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500093i32 as _);
pub const SPAPI_E_NO_INF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500086i32 as _);
pub const SPAPI_E_NO_SUCH_DEVICE_INTERFACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500059i32 as _);
pub const SPAPI_E_NO_SUCH_DEVINST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500085i32 as _);
pub const SPAPI_E_NO_SUCH_INTERFACE_CLASS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500066i32 as _);
pub const SPAPI_E_ONLY_VALIDATE_VIA_AUTHENTICODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500027i32 as _);
pub const SPAPI_E_PNP_REGISTRY_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500038i32 as _);
pub const SPAPI_E_REMOTE_COMM_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500063i32 as _);
pub const SPAPI_E_REMOTE_REQUEST_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500037i32 as _);
pub const SPAPI_E_SCE_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500040i32 as _);
pub const SPAPI_E_SECTION_NAME_TOO_LONG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500606i32 as _);
pub const SPAPI_E_SECTION_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500351i32 as _);
pub const SPAPI_E_SET_SYSTEM_RESTORE_POINT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500042i32 as _);
pub const SPAPI_E_SIGNATURE_OSATTRIBUTE_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500028i32 as _);
pub const SPAPI_E_UNKNOWN_EXCEPTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500039i32 as _);
pub const SPAPI_E_UNRECOVERABLE_STACK_OVERFLOW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146499840i32 as _);
pub const SPAPI_E_WRONG_INF_STYLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500352i32 as _);
pub const SPAPI_E_WRONG_INF_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146500022i32 as _);
pub const SQLITE_E_ABORT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574332i32 as _);
pub const SQLITE_E_ABORT_ROLLBACK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573820i32 as _);
pub const SQLITE_E_AUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574313i32 as _);
pub const SQLITE_E_BUSY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574331i32 as _);
pub const SQLITE_E_BUSY_RECOVERY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574075i32 as _);
pub const SQLITE_E_BUSY_SNAPSHOT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573819i32 as _);
pub const SQLITE_E_CANTOPEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574322i32 as _);
pub const SQLITE_E_CANTOPEN_CONVPATH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573298i32 as _);
pub const SQLITE_E_CANTOPEN_FULLPATH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573554i32 as _);
pub const SQLITE_E_CANTOPEN_ISDIR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573810i32 as _);
pub const SQLITE_E_CANTOPEN_NOTEMPDIR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574066i32 as _);
pub const SQLITE_E_CONSTRAINT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574317i32 as _);
pub const SQLITE_E_CONSTRAINT_CHECK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574061i32 as _);
pub const SQLITE_E_CONSTRAINT_COMMITHOOK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573805i32 as _);
pub const SQLITE_E_CONSTRAINT_FOREIGNKEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573549i32 as _);
pub const SQLITE_E_CONSTRAINT_FUNCTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573293i32 as _);
pub const SQLITE_E_CONSTRAINT_NOTNULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573037i32 as _);
pub const SQLITE_E_CONSTRAINT_PRIMARYKEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018572781i32 as _);
pub const SQLITE_E_CONSTRAINT_ROWID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018571757i32 as _);
pub const SQLITE_E_CONSTRAINT_TRIGGER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018572525i32 as _);
pub const SQLITE_E_CONSTRAINT_UNIQUE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018572269i32 as _);
pub const SQLITE_E_CONSTRAINT_VTAB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018572013i32 as _);
pub const SQLITE_E_CORRUPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574325i32 as _);
pub const SQLITE_E_CORRUPT_VTAB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574069i32 as _);
pub const SQLITE_E_DONE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574235i32 as _);
pub const SQLITE_E_EMPTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574320i32 as _);
pub const SQLITE_E_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574335i32 as _);
pub const SQLITE_E_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574312i32 as _);
pub const SQLITE_E_FULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574323i32 as _);
pub const SQLITE_E_INTERNAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574334i32 as _);
pub const SQLITE_E_INTERRUPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574327i32 as _);
pub const SQLITE_E_IOERR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574326i32 as _);
pub const SQLITE_E_IOERR_ACCESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018570998i32 as _);
pub const SQLITE_E_IOERR_AUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018567677i32 as _);
pub const SQLITE_E_IOERR_BLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018571510i32 as _);
pub const SQLITE_E_IOERR_CHECKRESERVEDLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018570742i32 as _);
pub const SQLITE_E_IOERR_CLOSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018570230i32 as _);
pub const SQLITE_E_IOERR_CONVPATH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018567670i32 as _);
pub const SQLITE_E_IOERR_DELETE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018571766i32 as _);
pub const SQLITE_E_IOERR_DELETE_NOENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018568438i32 as _);
pub const SQLITE_E_IOERR_DIR_CLOSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018569974i32 as _);
pub const SQLITE_E_IOERR_DIR_FSYNC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573046i32 as _);
pub const SQLITE_E_IOERR_FSTAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018572534i32 as _);
pub const SQLITE_E_IOERR_FSYNC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573302i32 as _);
pub const SQLITE_E_IOERR_GETTEMPPATH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018567926i32 as _);
pub const SQLITE_E_IOERR_LOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018570486i32 as _);
pub const SQLITE_E_IOERR_MMAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018568182i32 as _);
pub const SQLITE_E_IOERR_NOMEM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018571254i32 as _);
pub const SQLITE_E_IOERR_RDLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018572022i32 as _);
pub const SQLITE_E_IOERR_READ: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574070i32 as _);
pub const SQLITE_E_IOERR_SEEK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018568694i32 as _);
pub const SQLITE_E_IOERR_SHMLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018569206i32 as _);
pub const SQLITE_E_IOERR_SHMMAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018568950i32 as _);
pub const SQLITE_E_IOERR_SHMOPEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018569718i32 as _);
pub const SQLITE_E_IOERR_SHMSIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018569462i32 as _);
pub const SQLITE_E_IOERR_SHORT_READ: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573814i32 as _);
pub const SQLITE_E_IOERR_TRUNCATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018572790i32 as _);
pub const SQLITE_E_IOERR_UNLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018572278i32 as _);
pub const SQLITE_E_IOERR_VNODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018567678i32 as _);
pub const SQLITE_E_IOERR_WRITE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573558i32 as _);
pub const SQLITE_E_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574330i32 as _);
pub const SQLITE_E_LOCKED_SHAREDCACHE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574074i32 as _);
pub const SQLITE_E_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574316i32 as _);
pub const SQLITE_E_MISUSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574315i32 as _);
pub const SQLITE_E_NOLFS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574314i32 as _);
pub const SQLITE_E_NOMEM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574329i32 as _);
pub const SQLITE_E_NOTADB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574310i32 as _);
pub const SQLITE_E_NOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574324i32 as _);
pub const SQLITE_E_NOTICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574309i32 as _);
pub const SQLITE_E_NOTICE_RECOVER_ROLLBACK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573797i32 as _);
pub const SQLITE_E_NOTICE_RECOVER_WAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574053i32 as _);
pub const SQLITE_E_PERM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574333i32 as _);
pub const SQLITE_E_PROTOCOL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574321i32 as _);
pub const SQLITE_E_RANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574311i32 as _);
pub const SQLITE_E_READONLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574328i32 as _);
pub const SQLITE_E_READONLY_CANTLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573816i32 as _);
pub const SQLITE_E_READONLY_DBMOVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573304i32 as _);
pub const SQLITE_E_READONLY_RECOVERY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574072i32 as _);
pub const SQLITE_E_READONLY_ROLLBACK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018573560i32 as _);
pub const SQLITE_E_ROW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574236i32 as _);
pub const SQLITE_E_SCHEMA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574319i32 as _);
pub const SQLITE_E_TOOBIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574318i32 as _);
pub const SQLITE_E_WARNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574308i32 as _);
pub const SQLITE_E_WARNING_AUTOINDEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2018574052i32 as _);
pub const STATEREPOSITORY_ERROR_CACHE_CORRUPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733422i32 as _);
pub const STATEREPOSITORY_ERROR_DICTIONARY_CORRUPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733435i32 as _);
pub const STATEREPOSITORY_E_BLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733434i32 as _);
pub const STATEREPOSITORY_E_BUSY_RECOVERY_RETRY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733432i32 as _);
pub const STATEREPOSITORY_E_BUSY_RECOVERY_TIMEOUT_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733427i32 as _);
pub const STATEREPOSITORY_E_BUSY_RETRY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733433i32 as _);
pub const STATEREPOSITORY_E_BUSY_TIMEOUT_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733428i32 as _);
pub const STATEREPOSITORY_E_CACHE_NOT_INIITALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733419i32 as _);
pub const STATEREPOSITORY_E_CONCURRENCY_LOCKING_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733439i32 as _);
pub const STATEREPOSITORY_E_CONFIGURATION_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733437i32 as _);
pub const STATEREPOSITORY_E_DEPENDENCY_NOT_RESOLVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733418i32 as _);
pub const STATEREPOSITORY_E_LOCKED_RETRY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733431i32 as _);
pub const STATEREPOSITORY_E_LOCKED_SHAREDCACHE_RETRY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733430i32 as _);
pub const STATEREPOSITORY_E_LOCKED_SHAREDCACHE_TIMEOUT_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733425i32 as _);
pub const STATEREPOSITORY_E_LOCKED_TIMEOUT_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733426i32 as _);
pub const STATEREPOSITORY_E_SERVICE_STOP_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733424i32 as _);
pub const STATEREPOSITORY_E_STATEMENT_INPROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733438i32 as _);
pub const STATEREPOSITORY_E_TRANSACTION_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733429i32 as _);
pub const STATEREPOSITORY_E_UNKNOWN_SCHEMA_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733436i32 as _);
pub const STATEREPOSITORY_TRANSACTION_CALLER_ID_CHANGED: ::windows::core::HRESULT = ::windows::core::HRESULT(6750227i32 as _);
pub const STATEREPOSITORY_TRANSACTION_IN_PROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733420i32 as _);
pub const STATEREPOSTORY_E_NESTED_TRANSACTION_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2140733423i32 as _);
pub const STATUS_ABANDONED: NTSTATUS = NTSTATUS(128i32 as _);
pub const STATUS_ABANDONED_WAIT_0: NTSTATUS = NTSTATUS(128i32 as _);
pub const STATUS_ABANDONED_WAIT_63: NTSTATUS = NTSTATUS(191i32 as _);
pub const STATUS_ABANDON_HIBERFILE: NTSTATUS = NTSTATUS(1073741875i32 as _);
pub const STATUS_ABIOS_INVALID_COMMAND: NTSTATUS = NTSTATUS(-1073741549i32 as _);
pub const STATUS_ABIOS_INVALID_LID: NTSTATUS = NTSTATUS(-1073741548i32 as _);
pub const STATUS_ABIOS_INVALID_SELECTOR: NTSTATUS = NTSTATUS(-1073741546i32 as _);
pub const STATUS_ABIOS_LID_ALREADY_OWNED: NTSTATUS = NTSTATUS(-1073741551i32 as _);
pub const STATUS_ABIOS_LID_NOT_EXIST: NTSTATUS = NTSTATUS(-1073741552i32 as _);
pub const STATUS_ABIOS_NOT_LID_OWNER: NTSTATUS = NTSTATUS(-1073741550i32 as _);
pub const STATUS_ABIOS_NOT_PRESENT: NTSTATUS = NTSTATUS(-1073741553i32 as _);
pub const STATUS_ABIOS_SELECTOR_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1073741547i32 as _);
pub const STATUS_ACCESS_AUDIT_BY_POLICY: NTSTATUS = NTSTATUS(1073741874i32 as _);
pub const STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT: NTSTATUS = NTSTATUS(-1073740959i32 as _);
pub const STATUS_ACCESS_DISABLED_BY_POLICY_OTHER: NTSTATUS = NTSTATUS(-1073740956i32 as _);
pub const STATUS_ACCESS_DISABLED_BY_POLICY_PATH: NTSTATUS = NTSTATUS(-1073740958i32 as _);
pub const STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER: NTSTATUS = NTSTATUS(-1073740957i32 as _);
pub const STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY: NTSTATUS = NTSTATUS(-1073740942i32 as _);
pub const STATUS_ACCESS_VIOLATION: NTSTATUS = NTSTATUS(-1073741819i32 as _);
pub const STATUS_ACPI_ACQUIRE_GLOBAL_LOCK: NTSTATUS = NTSTATUS(-1072431086i32 as _);
pub const STATUS_ACPI_ADDRESS_NOT_MAPPED: NTSTATUS = NTSTATUS(-1072431092i32 as _);
pub const STATUS_ACPI_ALREADY_INITIALIZED: NTSTATUS = NTSTATUS(-1072431085i32 as _);
pub const STATUS_ACPI_ASSERT_FAILED: NTSTATUS = NTSTATUS(-1072431101i32 as _);
pub const STATUS_ACPI_FATAL: NTSTATUS = NTSTATUS(-1072431098i32 as _);
pub const STATUS_ACPI_HANDLER_COLLISION: NTSTATUS = NTSTATUS(-1072431090i32 as _);
pub const STATUS_ACPI_INCORRECT_ARGUMENT_COUNT: NTSTATUS = NTSTATUS(-1072431093i32 as _);
pub const STATUS_ACPI_INVALID_ACCESS_SIZE: NTSTATUS = NTSTATUS(-1072431087i32 as _);
pub const STATUS_ACPI_INVALID_ARGTYPE: NTSTATUS = NTSTATUS(-1072431096i32 as _);
pub const STATUS_ACPI_INVALID_ARGUMENT: NTSTATUS = NTSTATUS(-1072431099i32 as _);
pub const STATUS_ACPI_INVALID_DATA: NTSTATUS = NTSTATUS(-1072431089i32 as _);
pub const STATUS_ACPI_INVALID_EVENTTYPE: NTSTATUS = NTSTATUS(-1072431091i32 as _);
pub const STATUS_ACPI_INVALID_INDEX: NTSTATUS = NTSTATUS(-1072431100i32 as _);
pub const STATUS_ACPI_INVALID_MUTEX_LEVEL: NTSTATUS = NTSTATUS(-1072431083i32 as _);
pub const STATUS_ACPI_INVALID_OBJTYPE: NTSTATUS = NTSTATUS(-1072431095i32 as _);
pub const STATUS_ACPI_INVALID_OPCODE: NTSTATUS = NTSTATUS(-1072431103i32 as _);
pub const STATUS_ACPI_INVALID_REGION: NTSTATUS = NTSTATUS(-1072431088i32 as _);
pub const STATUS_ACPI_INVALID_SUPERNAME: NTSTATUS = NTSTATUS(-1072431097i32 as _);
pub const STATUS_ACPI_INVALID_TABLE: NTSTATUS = NTSTATUS(-1072431079i32 as _);
pub const STATUS_ACPI_INVALID_TARGETTYPE: NTSTATUS = NTSTATUS(-1072431094i32 as _);
pub const STATUS_ACPI_MUTEX_NOT_OWNED: NTSTATUS = NTSTATUS(-1072431082i32 as _);
pub const STATUS_ACPI_MUTEX_NOT_OWNER: NTSTATUS = NTSTATUS(-1072431081i32 as _);
pub const STATUS_ACPI_NOT_INITIALIZED: NTSTATUS = NTSTATUS(-1072431084i32 as _);
pub const STATUS_ACPI_POWER_REQUEST_FAILED: NTSTATUS = NTSTATUS(-1072431071i32 as _);
pub const STATUS_ACPI_REG_HANDLER_FAILED: NTSTATUS = NTSTATUS(-1072431072i32 as _);
pub const STATUS_ACPI_RS_ACCESS: NTSTATUS = NTSTATUS(-1072431080i32 as _);
pub const STATUS_ACPI_STACK_OVERFLOW: NTSTATUS = NTSTATUS(-1072431102i32 as _);
pub const STATUS_ADAPTER_HARDWARE_ERROR: NTSTATUS = NTSTATUS(-1073741630i32 as _);
pub const STATUS_ADDRESS_ALREADY_ASSOCIATED: NTSTATUS = NTSTATUS(-1073741256i32 as _);
pub const STATUS_ADDRESS_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1073741302i32 as _);
pub const STATUS_ADDRESS_CLOSED: NTSTATUS = NTSTATUS(-1073741301i32 as _);
pub const STATUS_ADDRESS_NOT_ASSOCIATED: NTSTATUS = NTSTATUS(-1073741255i32 as _);
pub const STATUS_ADMINLESS_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1073700348i32 as _);
pub const STATUS_ADVANCED_INSTALLER_FAILED: NTSTATUS = NTSTATUS(-1072365536i32 as _);
pub const STATUS_AGENTS_EXHAUSTED: NTSTATUS = NTSTATUS(-1073741691i32 as _);
pub const STATUS_ALERTED: NTSTATUS = NTSTATUS(257i32 as _);
pub const STATUS_ALIAS_EXISTS: NTSTATUS = NTSTATUS(-1073741484i32 as _);
pub const STATUS_ALLOCATE_BUCKET: NTSTATUS = NTSTATUS(-1073741265i32 as _);
pub const STATUS_ALLOTTED_SPACE_EXCEEDED: NTSTATUS = NTSTATUS(-1073741671i32 as _);
pub const STATUS_ALL_SIDS_FILTERED: NTSTATUS = NTSTATUS(-1073740962i32 as _);
pub const STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1073740798i32 as _);
pub const STATUS_ALPC_CHECK_COMPLETION_LIST: NTSTATUS = NTSTATUS(1073741872i32 as _);
pub const STATUS_ALREADY_COMMITTED: NTSTATUS = NTSTATUS(-1073741791i32 as _);
pub const STATUS_ALREADY_COMPLETE: NTSTATUS = NTSTATUS(255i32 as _);
pub const STATUS_ALREADY_DISCONNECTED: NTSTATUS = NTSTATUS(-2147483611i32 as _);
pub const STATUS_ALREADY_HAS_STREAM_ID: NTSTATUS = NTSTATUS(-1073740530i32 as _);
pub const STATUS_ALREADY_INITIALIZED: NTSTATUS = NTSTATUS(-1073740528i32 as _);
pub const STATUS_ALREADY_REGISTERED: NTSTATUS = NTSTATUS(-1073740008i32 as _);
pub const STATUS_ALREADY_WIN32: NTSTATUS = NTSTATUS(1073741851i32 as _);
pub const STATUS_AMBIGUOUS_SYSTEM_DEVICE: NTSTATUS = NTSTATUS(-1073740719i32 as _);
pub const STATUS_APC_RETURNED_WHILE_IMPERSONATING: NTSTATUS = NTSTATUS(-1073740015i32 as _);
pub const STATUS_APISET_NOT_HOSTED: NTSTATUS = NTSTATUS(-1073740671i32 as _);
pub const STATUS_APISET_NOT_PRESENT: NTSTATUS = NTSTATUS(-1073740670i32 as _);
pub const STATUS_APPEXEC_APP_COMPAT_BLOCK: NTSTATUS = NTSTATUS(-1058275320i32 as _);
pub const STATUS_APPEXEC_CALLER_WAIT_TIMEOUT: NTSTATUS = NTSTATUS(-1058275319i32 as _);
pub const STATUS_APPEXEC_CALLER_WAIT_TIMEOUT_LICENSING: NTSTATUS = NTSTATUS(-1058275317i32 as _);
pub const STATUS_APPEXEC_CALLER_WAIT_TIMEOUT_RESOURCES: NTSTATUS = NTSTATUS(-1058275316i32 as _);
pub const STATUS_APPEXEC_CALLER_WAIT_TIMEOUT_TERMINATION: NTSTATUS = NTSTATUS(-1058275318i32 as _);
pub const STATUS_APPEXEC_CONDITION_NOT_SATISFIED: NTSTATUS = NTSTATUS(-1058275328i32 as _);
pub const STATUS_APPEXEC_HANDLE_INVALIDATED: NTSTATUS = NTSTATUS(-1058275327i32 as _);
pub const STATUS_APPEXEC_HOST_ID_MISMATCH: NTSTATUS = NTSTATUS(-1058275322i32 as _);
pub const STATUS_APPEXEC_INVALID_HOST_GENERATION: NTSTATUS = NTSTATUS(-1058275326i32 as _);
pub const STATUS_APPEXEC_INVALID_HOST_STATE: NTSTATUS = NTSTATUS(-1058275324i32 as _);
pub const STATUS_APPEXEC_NO_DONOR: NTSTATUS = NTSTATUS(-1058275323i32 as _);
pub const STATUS_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION: NTSTATUS = NTSTATUS(-1058275325i32 as _);
pub const STATUS_APPEXEC_UNKNOWN_USER: NTSTATUS = NTSTATUS(-1058275321i32 as _);
pub const STATUS_APPHELP_BLOCK: NTSTATUS = NTSTATUS(-1073740963i32 as _);
pub const STATUS_APPX_FILE_NOT_ENCRYPTED: NTSTATUS = NTSTATUS(-1073740634i32 as _);
pub const STATUS_APPX_INTEGRITY_FAILURE_CLR_NGEN: NTSTATUS = NTSTATUS(-1073740673i32 as _);
pub const STATUS_APP_DATA_CORRUPT: NTSTATUS = NTSTATUS(-1073700221i32 as _);
pub const STATUS_APP_DATA_EXPIRED: NTSTATUS = NTSTATUS(-1073700222i32 as _);
pub const STATUS_APP_DATA_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1073700220i32 as _);
pub const STATUS_APP_DATA_NOT_FOUND: NTSTATUS = NTSTATUS(-1073700223i32 as _);
pub const STATUS_APP_DATA_REBOOT_REQUIRED: NTSTATUS = NTSTATUS(-1073700219i32 as _);
pub const STATUS_APP_INIT_FAILURE: NTSTATUS = NTSTATUS(-1073741499i32 as _);
pub const STATUS_ARBITRATION_UNHANDLED: NTSTATUS = NTSTATUS(1073741862i32 as _);
pub const STATUS_ARRAY_BOUNDS_EXCEEDED: NTSTATUS = NTSTATUS(-1073741684i32 as _);
pub const STATUS_ASSERTION_FAILURE: NTSTATUS = NTSTATUS(-1073740768i32 as _);
pub const STATUS_ATTACHED_EXECUTABLE_MEMORY_WRITE: NTSTATUS = NTSTATUS(-1073739995i32 as _);
pub const STATUS_ATTRIBUTE_NOT_PRESENT: NTSTATUS = NTSTATUS(-1073740532i32 as _);
pub const STATUS_AUDIO_ENGINE_NODE_NOT_FOUND: NTSTATUS = NTSTATUS(-1069285375i32 as _);
pub const STATUS_AUDITING_DISABLED: NTSTATUS = NTSTATUS(-1073740970i32 as _);
pub const STATUS_AUDIT_FAILED: NTSTATUS = NTSTATUS(-1073741244i32 as _);
pub const STATUS_AUTHIP_FAILURE: NTSTATUS = NTSTATUS(-1073700730i32 as _);
pub const STATUS_AUTH_TAG_MISMATCH: NTSTATUS = NTSTATUS(-1073700862i32 as _);
pub const STATUS_BACKUP_CONTROLLER: NTSTATUS = NTSTATUS(-1073741433i32 as _);
pub const STATUS_BAD_BINDINGS: NTSTATUS = NTSTATUS(-1073740965i32 as _);
pub const STATUS_BAD_CLUSTERS: NTSTATUS = NTSTATUS(-1073739771i32 as _);
pub const STATUS_BAD_COMPRESSION_BUFFER: NTSTATUS = NTSTATUS(-1073741246i32 as _);
pub const STATUS_BAD_CURRENT_DIRECTORY: NTSTATUS = NTSTATUS(1073741831i32 as _);
pub const STATUS_BAD_DATA: NTSTATUS = NTSTATUS(-1073739509i32 as _);
pub const STATUS_BAD_DESCRIPTOR_FORMAT: NTSTATUS = NTSTATUS(-1073741593i32 as _);
pub const STATUS_BAD_DEVICE_TYPE: NTSTATUS = NTSTATUS(-1073741621i32 as _);
pub const STATUS_BAD_DLL_ENTRYPOINT: NTSTATUS = NTSTATUS(-1073741231i32 as _);
pub const STATUS_BAD_FILE_TYPE: NTSTATUS = NTSTATUS(-1073739517i32 as _);
pub const STATUS_BAD_FUNCTION_TABLE: NTSTATUS = NTSTATUS(-1073741569i32 as _);
pub const STATUS_BAD_IMPERSONATION_LEVEL: NTSTATUS = NTSTATUS(-1073741659i32 as _);
pub const STATUS_BAD_INHERITANCE_ACL: NTSTATUS = NTSTATUS(-1073741699i32 as _);
pub const STATUS_BAD_INITIAL_PC: NTSTATUS = NTSTATUS(-1073741814i32 as _);
pub const STATUS_BAD_INITIAL_STACK: NTSTATUS = NTSTATUS(-1073741815i32 as _);
pub const STATUS_BAD_KEY: NTSTATUS = NTSTATUS(-1073739510i32 as _);
pub const STATUS_BAD_LOGON_SESSION_STATE: NTSTATUS = NTSTATUS(-1073741564i32 as _);
pub const STATUS_BAD_MASTER_BOOT_RECORD: NTSTATUS = NTSTATUS(-1073741655i32 as _);
pub const STATUS_BAD_MCFG_TABLE: NTSTATUS = NTSTATUS(-1073739512i32 as _);
pub const STATUS_BAD_NETWORK_NAME: NTSTATUS = NTSTATUS(-1073741620i32 as _);
pub const STATUS_BAD_NETWORK_PATH: NTSTATUS = NTSTATUS(-1073741634i32 as _);
pub const STATUS_BAD_REMOTE_ADAPTER: NTSTATUS = NTSTATUS(-1073741627i32 as _);
pub const STATUS_BAD_SERVICE_ENTRYPOINT: NTSTATUS = NTSTATUS(-1073741230i32 as _);
pub const STATUS_BAD_STACK: NTSTATUS = NTSTATUS(-1073741784i32 as _);
pub const STATUS_BAD_TOKEN_TYPE: NTSTATUS = NTSTATUS(-1073741656i32 as _);
pub const STATUS_BAD_VALIDATION_CLASS: NTSTATUS = NTSTATUS(-1073741657i32 as _);
pub const STATUS_BAD_WORKING_SET_LIMIT: NTSTATUS = NTSTATUS(-1073741748i32 as _);
pub const STATUS_BCD_NOT_ALL_ENTRIES_IMPORTED: NTSTATUS = NTSTATUS(-2143748095i32 as _);
pub const STATUS_BCD_NOT_ALL_ENTRIES_SYNCHRONIZED: NTSTATUS = NTSTATUS(-2143748093i32 as _);
pub const STATUS_BCD_TOO_MANY_ELEMENTS: NTSTATUS = NTSTATUS(-1070006270i32 as _);
pub const STATUS_BEGINNING_OF_MEDIA: NTSTATUS = NTSTATUS(-2147483617i32 as _);
pub const STATUS_BEYOND_VDL: NTSTATUS = NTSTATUS(-1073740750i32 as _);
pub const STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT: NTSTATUS = NTSTATUS(-1073741458i32 as _);
pub const STATUS_BIZRULES_NOT_ENABLED: NTSTATUS = NTSTATUS(1073741876i32 as _);
pub const STATUS_BLOCKED_BY_PARENTAL_CONTROLS: NTSTATUS = NTSTATUS(-1073740664i32 as _);
pub const STATUS_BLOCK_TOO_MANY_REFERENCES: NTSTATUS = NTSTATUS(-1073740660i32 as _);
pub const STATUS_BREAKPOINT: NTSTATUS = NTSTATUS(-2147483645i32 as _);
pub const STATUS_BTH_ATT_ATTRIBUTE_NOT_FOUND: NTSTATUS = NTSTATUS(-1069416438i32 as _);
pub const STATUS_BTH_ATT_ATTRIBUTE_NOT_LONG: NTSTATUS = NTSTATUS(-1069416437i32 as _);
pub const STATUS_BTH_ATT_INSUFFICIENT_AUTHENTICATION: NTSTATUS = NTSTATUS(-1069416443i32 as _);
pub const STATUS_BTH_ATT_INSUFFICIENT_AUTHORIZATION: NTSTATUS = NTSTATUS(-1069416440i32 as _);
pub const STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION: NTSTATUS = NTSTATUS(-1069416433i32 as _);
pub const STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE: NTSTATUS = NTSTATUS(-1069416436i32 as _);
pub const STATUS_BTH_ATT_INSUFFICIENT_RESOURCES: NTSTATUS = NTSTATUS(-1069416431i32 as _);
pub const STATUS_BTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH: NTSTATUS = NTSTATUS(-1069416435i32 as _);
pub const STATUS_BTH_ATT_INVALID_HANDLE: NTSTATUS = NTSTATUS(-1069416447i32 as _);
pub const STATUS_BTH_ATT_INVALID_OFFSET: NTSTATUS = NTSTATUS(-1069416441i32 as _);
pub const STATUS_BTH_ATT_INVALID_PDU: NTSTATUS = NTSTATUS(-1069416444i32 as _);
pub const STATUS_BTH_ATT_PREPARE_QUEUE_FULL: NTSTATUS = NTSTATUS(-1069416439i32 as _);
pub const STATUS_BTH_ATT_READ_NOT_PERMITTED: NTSTATUS = NTSTATUS(-1069416446i32 as _);
pub const STATUS_BTH_ATT_REQUEST_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1069416442i32 as _);
pub const STATUS_BTH_ATT_UNKNOWN_ERROR: NTSTATUS = NTSTATUS(-1069412352i32 as _);
pub const STATUS_BTH_ATT_UNLIKELY: NTSTATUS = NTSTATUS(-1069416434i32 as _);
pub const STATUS_BTH_ATT_UNSUPPORTED_GROUP_TYPE: NTSTATUS = NTSTATUS(-1069416432i32 as _);
pub const STATUS_BTH_ATT_WRITE_NOT_PERMITTED: NTSTATUS = NTSTATUS(-1069416445i32 as _);
pub const STATUS_BUFFER_ALL_ZEROS: NTSTATUS = NTSTATUS(279i32 as _);
pub const STATUS_BUFFER_OVERFLOW: NTSTATUS = NTSTATUS(-2147483643i32 as _);
pub const STATUS_BUFFER_TOO_SMALL: NTSTATUS = NTSTATUS(-1073741789i32 as _);
pub const STATUS_BUS_RESET: NTSTATUS = NTSTATUS(-2147483619i32 as _);
pub const STATUS_BYPASSIO_FLT_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073740590i32 as _);
pub const STATUS_CACHE_PAGE_LOCKED: NTSTATUS = NTSTATUS(277i32 as _);
pub const STATUS_CALLBACK_BYPASS: NTSTATUS = NTSTATUS(-1073740541i32 as _);
pub const STATUS_CALLBACK_INVOKE_INLINE: NTSTATUS = NTSTATUS(-1073740661i32 as _);
pub const STATUS_CALLBACK_POP_STACK: NTSTATUS = NTSTATUS(-1073740765i32 as _);
pub const STATUS_CALLBACK_RETURNED_LANG: NTSTATUS = NTSTATUS(-1073740001i32 as _);
pub const STATUS_CALLBACK_RETURNED_LDR_LOCK: NTSTATUS = NTSTATUS(-1073740002i32 as _);
pub const STATUS_CALLBACK_RETURNED_PRI_BACK: NTSTATUS = NTSTATUS(-1073740000i32 as _);
pub const STATUS_CALLBACK_RETURNED_THREAD_AFFINITY: NTSTATUS = NTSTATUS(-1073739999i32 as _);
pub const STATUS_CALLBACK_RETURNED_THREAD_PRIORITY: NTSTATUS = NTSTATUS(-1073740005i32 as _);
pub const STATUS_CALLBACK_RETURNED_TRANSACTION: NTSTATUS = NTSTATUS(-1073740003i32 as _);
pub const STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING: NTSTATUS = NTSTATUS(-1073740016i32 as _);
pub const STATUS_CANCELLED: NTSTATUS = NTSTATUS(-1073741536i32 as _);
pub const STATUS_CANNOT_ABORT_TRANSACTIONS: NTSTATUS = NTSTATUS(-1072103347i32 as _);
pub const STATUS_CANNOT_ACCEPT_TRANSACTED_WORK: NTSTATUS = NTSTATUS(-1072103348i32 as _);
pub const STATUS_CANNOT_BREAK_OPLOCK: NTSTATUS = NTSTATUS(-1073739511i32 as _);
pub const STATUS_CANNOT_DELETE: NTSTATUS = NTSTATUS(-1073741535i32 as _);
pub const STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION: NTSTATUS = NTSTATUS(-1072103356i32 as _);
pub const STATUS_CANNOT_GRANT_REQUESTED_OPLOCK: NTSTATUS = NTSTATUS(-2147483602i32 as _);
pub const STATUS_CANNOT_IMPERSONATE: NTSTATUS = NTSTATUS(-1073741555i32 as _);
pub const STATUS_CANNOT_LOAD_REGISTRY_FILE: NTSTATUS = NTSTATUS(-1073741288i32 as _);
pub const STATUS_CANNOT_MAKE: NTSTATUS = NTSTATUS(-1073741078i32 as _);
pub const STATUS_CANNOT_SWITCH_RUNLEVEL: NTSTATUS = NTSTATUS(-1073700543i32 as _);
pub const STATUS_CANT_ACCESS_DOMAIN_INFO: NTSTATUS = NTSTATUS(-1073741606i32 as _);
pub const STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY: NTSTATUS = NTSTATUS(-1072103369i32 as _);
pub const STATUS_CANT_CLEAR_ENCRYPTION_FLAG: NTSTATUS = NTSTATUS(-1073740616i32 as _);
pub const STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS: NTSTATUS = NTSTATUS(-1072103386i32 as _);
pub const STATUS_CANT_CROSS_RM_BOUNDARY: NTSTATUS = NTSTATUS(-1072103368i32 as _);
pub const STATUS_CANT_DISABLE_MANDATORY: NTSTATUS = NTSTATUS(-1073741731i32 as _);
pub const STATUS_CANT_ENABLE_DENY_ONLY: NTSTATUS = NTSTATUS(-1073741133i32 as _);
pub const STATUS_CANT_OPEN_ANONYMOUS: NTSTATUS = NTSTATUS(-1073741658i32 as _);
pub const STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT: NTSTATUS = NTSTATUS(-1072103387i32 as _);
pub const STATUS_CANT_RECOVER_WITH_HANDLE_OPEN: NTSTATUS = NTSTATUS(-2145845199i32 as _);
pub const STATUS_CANT_TERMINATE_SELF: NTSTATUS = NTSTATUS(-1073741605i32 as _);
pub const STATUS_CANT_WAIT: NTSTATUS = NTSTATUS(-1073741608i32 as _);
pub const STATUS_CARDBUS_NOT_SUPPORTED: NTSTATUS = NTSTATUS(1073741863i32 as _);
pub const STATUS_CASE_DIFFERING_NAMES_IN_DIR: NTSTATUS = NTSTATUS(-1073740621i32 as _);
pub const STATUS_CASE_SENSITIVE_PATH: NTSTATUS = NTSTATUS(-1073740614i32 as _);
pub const STATUS_CC_NEEDS_CALLBACK_SECTION_DRAIN: NTSTATUS = NTSTATUS(-1073700856i32 as _);
pub const STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE: NTSTATUS = NTSTATUS(-1073740012i32 as _);
pub const STATUS_CERTIFICATE_VALIDATION_PREFERENCE_CONFLICT: NTSTATUS = NTSTATUS(-1073741387i32 as _);
pub const STATUS_CHECKING_FILE_SYSTEM: NTSTATUS = NTSTATUS(1073741844i32 as _);
pub const STATUS_CHECKOUT_REQUIRED: NTSTATUS = NTSTATUS(-1073739518i32 as _);
pub const STATUS_CHILD_MUST_BE_VOLATILE: NTSTATUS = NTSTATUS(-1073741439i32 as _);
pub const STATUS_CHILD_PROCESS_BLOCKED: NTSTATUS = NTSTATUS(-1073740643i32 as _);
pub const STATUS_CIMFS_IMAGE_CORRUPT: NTSTATUS = NTSTATUS(-1073692671i32 as _);
pub const STATUS_CIMFS_IMAGE_VERSION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073692670i32 as _);
pub const STATUS_CLEANER_CARTRIDGE_INSTALLED: NTSTATUS = NTSTATUS(-2147483609i32 as _);
pub const STATUS_CLIENT_SERVER_PARAMETERS_INVALID: NTSTATUS = NTSTATUS(-1073741277i32 as _);
pub const STATUS_CLIP_DEVICE_LICENSE_MISSING: NTSTATUS = NTSTATUS(-1058406397i32 as _);
pub const STATUS_CLIP_KEYHOLDER_LICENSE_MISSING_OR_INVALID: NTSTATUS = NTSTATUS(-1058406395i32 as _);
pub const STATUS_CLIP_LICENSE_DEVICE_ID_MISMATCH: NTSTATUS = NTSTATUS(-1058406390i32 as _);
pub const STATUS_CLIP_LICENSE_EXPIRED: NTSTATUS = NTSTATUS(-1058406394i32 as _);
pub const STATUS_CLIP_LICENSE_HARDWARE_ID_OUT_OF_TOLERANCE: NTSTATUS = NTSTATUS(-1058406391i32 as _);
pub const STATUS_CLIP_LICENSE_INVALID_SIGNATURE: NTSTATUS = NTSTATUS(-1058406396i32 as _);
pub const STATUS_CLIP_LICENSE_NOT_FOUND: NTSTATUS = NTSTATUS(-1058406398i32 as _);
pub const STATUS_CLIP_LICENSE_NOT_SIGNED: NTSTATUS = NTSTATUS(-1058406392i32 as _);
pub const STATUS_CLIP_LICENSE_SIGNED_BY_UNKNOWN_SOURCE: NTSTATUS = NTSTATUS(-1058406393i32 as _);
pub const STATUS_CLOUD_FILE_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1073688808i32 as _);
pub const STATUS_CLOUD_FILE_ALREADY_CONNECTED: NTSTATUS = NTSTATUS(-1073688823i32 as _);
pub const STATUS_CLOUD_FILE_AUTHENTICATION_FAILED: NTSTATUS = NTSTATUS(-1073688817i32 as _);
pub const STATUS_CLOUD_FILE_CONNECTED_PROVIDER_ONLY: NTSTATUS = NTSTATUS(-1073688819i32 as _);
pub const STATUS_CLOUD_FILE_DEHYDRATION_DISALLOWED: NTSTATUS = NTSTATUS(-1073688800i32 as _);
pub const STATUS_CLOUD_FILE_INCOMPATIBLE_HARDLINKS: NTSTATUS = NTSTATUS(-1073688807i32 as _);
pub const STATUS_CLOUD_FILE_INSUFFICIENT_RESOURCES: NTSTATUS = NTSTATUS(-1073688816i32 as _);
pub const STATUS_CLOUD_FILE_INVALID_REQUEST: NTSTATUS = NTSTATUS(-1073688821i32 as _);
pub const STATUS_CLOUD_FILE_IN_USE: NTSTATUS = NTSTATUS(-1073688812i32 as _);
pub const STATUS_CLOUD_FILE_METADATA_CORRUPT: NTSTATUS = NTSTATUS(-1073688830i32 as _);
pub const STATUS_CLOUD_FILE_METADATA_TOO_LARGE: NTSTATUS = NTSTATUS(-1073688829i32 as _);
pub const STATUS_CLOUD_FILE_NETWORK_UNAVAILABLE: NTSTATUS = NTSTATUS(-1073688815i32 as _);
pub const STATUS_CLOUD_FILE_NOT_IN_SYNC: NTSTATUS = NTSTATUS(-1073688824i32 as _);
pub const STATUS_CLOUD_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073688822i32 as _);
pub const STATUS_CLOUD_FILE_NOT_UNDER_SYNC_ROOT: NTSTATUS = NTSTATUS(-1073688813i32 as _);
pub const STATUS_CLOUD_FILE_PINNED: NTSTATUS = NTSTATUS(-1073688811i32 as _);
pub const STATUS_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH: NTSTATUS = NTSTATUS(-2147430656i32 as _);
pub const STATUS_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE: NTSTATUS = NTSTATUS(-2147430652i32 as _);
pub const STATUS_CLOUD_FILE_PROPERTY_CORRUPT: NTSTATUS = NTSTATUS(-1073688809i32 as _);
pub const STATUS_CLOUD_FILE_PROPERTY_LOCK_CONFLICT: NTSTATUS = NTSTATUS(-1073688806i32 as _);
pub const STATUS_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073688826i32 as _);
pub const STATUS_CLOUD_FILE_PROVIDER_NOT_RUNNING: NTSTATUS = NTSTATUS(-1073688831i32 as _);
pub const STATUS_CLOUD_FILE_PROVIDER_TERMINATED: NTSTATUS = NTSTATUS(-1073688803i32 as _);
pub const STATUS_CLOUD_FILE_READ_ONLY_VOLUME: NTSTATUS = NTSTATUS(-1073688820i32 as _);
pub const STATUS_CLOUD_FILE_REQUEST_ABORTED: NTSTATUS = NTSTATUS(-1073688810i32 as _);
pub const STATUS_CLOUD_FILE_REQUEST_CANCELED: NTSTATUS = NTSTATUS(-1073688805i32 as _);
pub const STATUS_CLOUD_FILE_REQUEST_TIMEOUT: NTSTATUS = NTSTATUS(-1073688801i32 as _);
pub const STATUS_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT: NTSTATUS = NTSTATUS(-1073688832i32 as _);
pub const STATUS_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS: NTSTATUS = NTSTATUS(-2147430651i32 as _);
pub const STATUS_CLOUD_FILE_UNSUCCESSFUL: NTSTATUS = NTSTATUS(-1073688814i32 as _);
pub const STATUS_CLOUD_FILE_VALIDATION_FAILED: NTSTATUS = NTSTATUS(-1073688818i32 as _);
pub const STATUS_CLUSTER_CAM_TICKET_REPLAY_DETECTED: NTSTATUS = NTSTATUS(-1072496591i32 as _);
pub const STATUS_CLUSTER_CSV_AUTO_PAUSE_ERROR: NTSTATUS = NTSTATUS(-1072496607i32 as _);
pub const STATUS_CLUSTER_CSV_INVALID_HANDLE: NTSTATUS = NTSTATUS(-1072496599i32 as _);
pub const STATUS_CLUSTER_CSV_NOT_REDIRECTED: NTSTATUS = NTSTATUS(-1072496605i32 as _);
pub const STATUS_CLUSTER_CSV_NO_SNAPSHOTS: NTSTATUS = NTSTATUS(-1072496601i32 as _);
pub const STATUS_CLUSTER_CSV_READ_OPLOCK_BREAK_IN_PROGRESS: NTSTATUS = NTSTATUS(-1072496608i32 as _);
pub const STATUS_CLUSTER_CSV_REDIRECTED: NTSTATUS = NTSTATUS(-1072496606i32 as _);
pub const STATUS_CLUSTER_CSV_SNAPSHOT_CREATION_IN_PROGRESS: NTSTATUS = NTSTATUS(-1072496603i32 as _);
pub const STATUS_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR: NTSTATUS = NTSTATUS(-1072496592i32 as _);
pub const STATUS_CLUSTER_CSV_VOLUME_DRAINING: NTSTATUS = NTSTATUS(-1072496604i32 as _);
pub const STATUS_CLUSTER_CSV_VOLUME_DRAINING_SUCCEEDED_DOWNLEVEL: NTSTATUS = NTSTATUS(-1072496602i32 as _);
pub const STATUS_CLUSTER_CSV_VOLUME_NOT_LOCAL: NTSTATUS = NTSTATUS(-1072496615i32 as _);
pub const STATUS_CLUSTER_INVALID_NETWORK: NTSTATUS = NTSTATUS(-1072496624i32 as _);
pub const STATUS_CLUSTER_INVALID_NETWORK_PROVIDER: NTSTATUS = NTSTATUS(-1072496629i32 as _);
pub const STATUS_CLUSTER_INVALID_NODE: NTSTATUS = NTSTATUS(-1072496639i32 as _);
pub const STATUS_CLUSTER_INVALID_REQUEST: NTSTATUS = NTSTATUS(-1072496630i32 as _);
pub const STATUS_CLUSTER_JOIN_IN_PROGRESS: NTSTATUS = NTSTATUS(-1072496637i32 as _);
pub const STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS: NTSTATUS = NTSTATUS(-1072496625i32 as _);
pub const STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND: NTSTATUS = NTSTATUS(-1072496635i32 as _);
pub const STATUS_CLUSTER_NETINTERFACE_EXISTS: NTSTATUS = NTSTATUS(-1072496632i32 as _);
pub const STATUS_CLUSTER_NETINTERFACE_NOT_FOUND: NTSTATUS = NTSTATUS(-1072496631i32 as _);
pub const STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE: NTSTATUS = NTSTATUS(-2146238460i32 as _);
pub const STATUS_CLUSTER_NETWORK_ALREADY_ONLINE: NTSTATUS = NTSTATUS(-2146238461i32 as _);
pub const STATUS_CLUSTER_NETWORK_EXISTS: NTSTATUS = NTSTATUS(-1072496634i32 as _);
pub const STATUS_CLUSTER_NETWORK_NOT_FOUND: NTSTATUS = NTSTATUS(-1072496633i32 as _);
pub const STATUS_CLUSTER_NETWORK_NOT_INTERNAL: NTSTATUS = NTSTATUS(-1072496618i32 as _);
pub const STATUS_CLUSTER_NODE_ALREADY_DOWN: NTSTATUS = NTSTATUS(-2146238462i32 as _);
pub const STATUS_CLUSTER_NODE_ALREADY_MEMBER: NTSTATUS = NTSTATUS(-2146238459i32 as _);
pub const STATUS_CLUSTER_NODE_ALREADY_UP: NTSTATUS = NTSTATUS(-2146238463i32 as _);
pub const STATUS_CLUSTER_NODE_DOWN: NTSTATUS = NTSTATUS(-1072496628i32 as _);
pub const STATUS_CLUSTER_NODE_EXISTS: NTSTATUS = NTSTATUS(-1072496638i32 as _);
pub const STATUS_CLUSTER_NODE_NOT_FOUND: NTSTATUS = NTSTATUS(-1072496636i32 as _);
pub const STATUS_CLUSTER_NODE_NOT_MEMBER: NTSTATUS = NTSTATUS(-1072496626i32 as _);
pub const STATUS_CLUSTER_NODE_NOT_PAUSED: NTSTATUS = NTSTATUS(-1072496620i32 as _);
pub const STATUS_CLUSTER_NODE_PAUSED: NTSTATUS = NTSTATUS(-1072496621i32 as _);
pub const STATUS_CLUSTER_NODE_UNREACHABLE: NTSTATUS = NTSTATUS(-1072496627i32 as _);
pub const STATUS_CLUSTER_NODE_UP: NTSTATUS = NTSTATUS(-1072496622i32 as _);
pub const STATUS_CLUSTER_NON_CSV_PATH: NTSTATUS = NTSTATUS(-1072496616i32 as _);
pub const STATUS_CLUSTER_NO_NET_ADAPTERS: NTSTATUS = NTSTATUS(-1072496623i32 as _);
pub const STATUS_CLUSTER_NO_SECURITY_CONTEXT: NTSTATUS = NTSTATUS(-1072496619i32 as _);
pub const STATUS_CLUSTER_POISONED: NTSTATUS = NTSTATUS(-1072496617i32 as _);
pub const STATUS_COMMITMENT_LIMIT: NTSTATUS = NTSTATUS(-1073741523i32 as _);
pub const STATUS_COMMITMENT_MINIMUM: NTSTATUS = NTSTATUS(-1073741112i32 as _);
pub const STATUS_COMPRESSED_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073740677i32 as _);
pub const STATUS_COMPRESSION_DISABLED: NTSTATUS = NTSTATUS(-1073740762i32 as _);
pub const STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION: NTSTATUS = NTSTATUS(-1072103338i32 as _);
pub const STATUS_COMPRESSION_NOT_BENEFICIAL: NTSTATUS = NTSTATUS(-1073740689i32 as _);
pub const STATUS_CONFLICTING_ADDRESSES: NTSTATUS = NTSTATUS(-1073741800i32 as _);
pub const STATUS_CONNECTION_ABORTED: NTSTATUS = NTSTATUS(-1073741247i32 as _);
pub const STATUS_CONNECTION_ACTIVE: NTSTATUS = NTSTATUS(-1073741253i32 as _);
pub const STATUS_CONNECTION_COUNT_LIMIT: NTSTATUS = NTSTATUS(-1073741242i32 as _);
pub const STATUS_CONNECTION_DISCONNECTED: NTSTATUS = NTSTATUS(-1073741300i32 as _);
pub const STATUS_CONNECTION_INVALID: NTSTATUS = NTSTATUS(-1073741254i32 as _);
pub const STATUS_CONNECTION_IN_USE: NTSTATUS = NTSTATUS(-1073741560i32 as _);
pub const STATUS_CONNECTION_REFUSED: NTSTATUS = NTSTATUS(-1073741258i32 as _);
pub const STATUS_CONNECTION_RESET: NTSTATUS = NTSTATUS(-1073741299i32 as _);
pub const STATUS_CONTAINER_ASSIGNED: NTSTATUS = NTSTATUS(-1073740536i32 as _);
pub const STATUS_CONTENT_BLOCKED: NTSTATUS = NTSTATUS(-1073739772i32 as _);
pub const STATUS_CONTEXT_MISMATCH: NTSTATUS = NTSTATUS(-1073740007i32 as _);
pub const STATUS_CONTEXT_STOWED_EXCEPTION: NTSTATUS = NTSTATUS(-1073741188i32 as _);
pub const STATUS_CONTROL_C_EXIT: NTSTATUS = NTSTATUS(-1073741510i32 as _);
pub const STATUS_CONTROL_STACK_VIOLATION: NTSTATUS = NTSTATUS(-1073741390i32 as _);
pub const STATUS_CONVERT_TO_LARGE: NTSTATUS = NTSTATUS(-1073741268i32 as _);
pub const STATUS_COPY_PROTECTION_FAILURE: NTSTATUS = NTSTATUS(-1073741051i32 as _);
pub const STATUS_CORRUPT_LOG_CLEARED: NTSTATUS = NTSTATUS(-1073739763i32 as _);
pub const STATUS_CORRUPT_LOG_CORRUPTED: NTSTATUS = NTSTATUS(-1073739766i32 as _);
pub const STATUS_CORRUPT_LOG_DELETED_FULL: NTSTATUS = NTSTATUS(-1073739764i32 as _);
pub const STATUS_CORRUPT_LOG_OVERFULL: NTSTATUS = NTSTATUS(-1073739767i32 as _);
pub const STATUS_CORRUPT_LOG_UNAVAILABLE: NTSTATUS = NTSTATUS(-1073739765i32 as _);
pub const STATUS_CORRUPT_LOG_UPLEVEL_RECORDS: NTSTATUS = NTSTATUS(-1073739759i32 as _);
pub const STATUS_CORRUPT_SYSTEM_FILE: NTSTATUS = NTSTATUS(-1073741116i32 as _);
pub const STATUS_COULD_NOT_INTERPRET: NTSTATUS = NTSTATUS(-1073741639i32 as _);
pub const STATUS_COULD_NOT_RESIZE_LOG: NTSTATUS = NTSTATUS(-2145845239i32 as _);
pub const STATUS_CPU_SET_INVALID: NTSTATUS = NTSTATUS(-1073741393i32 as _);
pub const STATUS_CRASH_DUMP: NTSTATUS = NTSTATUS(278i32 as _);
pub const STATUS_CRC_ERROR: NTSTATUS = NTSTATUS(-1073741761i32 as _);
pub const STATUS_CRED_REQUIRES_CONFIRMATION: NTSTATUS = NTSTATUS(-1073740736i32 as _);
pub const STATUS_CRM_PROTOCOL_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1072103409i32 as _);
pub const STATUS_CRM_PROTOCOL_NOT_FOUND: NTSTATUS = NTSTATUS(-1072103407i32 as _);
pub const STATUS_CROSSREALM_DELEGATION_FAILURE: NTSTATUS = NTSTATUS(-1073740789i32 as _);
pub const STATUS_CROSS_PARTITION_VIOLATION: NTSTATUS = NTSTATUS(-1073740277i32 as _);
pub const STATUS_CRYPTO_SYSTEM_INVALID: NTSTATUS = NTSTATUS(-1073741069i32 as _);
pub const STATUS_CSS_AUTHENTICATION_FAILURE: NTSTATUS = NTSTATUS(-1073741050i32 as _);
pub const STATUS_CSS_KEY_NOT_ESTABLISHED: NTSTATUS = NTSTATUS(-1073741048i32 as _);
pub const STATUS_CSS_KEY_NOT_PRESENT: NTSTATUS = NTSTATUS(-1073741049i32 as _);
pub const STATUS_CSS_REGION_MISMATCH: NTSTATUS = NTSTATUS(-1073741046i32 as _);
pub const STATUS_CSS_RESETS_EXHAUSTED: NTSTATUS = NTSTATUS(-1073741045i32 as _);
pub const STATUS_CSS_SCRAMBLED_SECTOR: NTSTATUS = NTSTATUS(-1073741047i32 as _);
pub const STATUS_CSV_IO_PAUSE_TIMEOUT: NTSTATUS = NTSTATUS(-1072496600i32 as _);
pub const STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE: NTSTATUS = NTSTATUS(-1073740733i32 as _);
pub const STATUS_CS_ENCRYPTION_FILE_NOT_CSE: NTSTATUS = NTSTATUS(-1073740731i32 as _);
pub const STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE: NTSTATUS = NTSTATUS(-1073740735i32 as _);
pub const STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE: NTSTATUS = NTSTATUS(-1073740732i32 as _);
pub const STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER: NTSTATUS = NTSTATUS(-1073740734i32 as _);
pub const STATUS_CTLOG_INCONSISTENT_TRACKING_FILE: NTSTATUS = NTSTATUS(-1069940700i32 as _);
pub const STATUS_CTLOG_INVALID_TRACKING_STATE: NTSTATUS = NTSTATUS(-1069940701i32 as _);
pub const STATUS_CTLOG_LOGFILE_SIZE_EXCEEDED_MAXSIZE: NTSTATUS = NTSTATUS(-1069940703i32 as _);
pub const STATUS_CTLOG_TRACKING_NOT_INITIALIZED: NTSTATUS = NTSTATUS(-1069940704i32 as _);
pub const STATUS_CTLOG_VHD_CHANGED_OFFLINE: NTSTATUS = NTSTATUS(-1069940702i32 as _);
pub const STATUS_CTL_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073741737i32 as _);
pub const STATUS_CTX_BAD_VIDEO_MODE: NTSTATUS = NTSTATUS(-1073086440i32 as _);
pub const STATUS_CTX_CDM_CONNECT: NTSTATUS = NTSTATUS(1074397188i32 as _);
pub const STATUS_CTX_CDM_DISCONNECT: NTSTATUS = NTSTATUS(1074397189i32 as _);
pub const STATUS_CTX_CLIENT_LICENSE_IN_USE: NTSTATUS = NTSTATUS(-1073086412i32 as _);
pub const STATUS_CTX_CLIENT_LICENSE_NOT_SET: NTSTATUS = NTSTATUS(-1073086413i32 as _);
pub const STATUS_CTX_CLIENT_QUERY_TIMEOUT: NTSTATUS = NTSTATUS(-1073086426i32 as _);
pub const STATUS_CTX_CLOSE_PENDING: NTSTATUS = NTSTATUS(-1073086458i32 as _);
pub const STATUS_CTX_CONSOLE_CONNECT: NTSTATUS = NTSTATUS(-1073086424i32 as _);
pub const STATUS_CTX_CONSOLE_DISCONNECT: NTSTATUS = NTSTATUS(-1073086425i32 as _);
pub const STATUS_CTX_GRAPHICS_INVALID: NTSTATUS = NTSTATUS(-1073086430i32 as _);
pub const STATUS_CTX_INVALID_MODEMNAME: NTSTATUS = NTSTATUS(-1073086455i32 as _);
pub const STATUS_CTX_INVALID_PD: NTSTATUS = NTSTATUS(-1073086462i32 as _);
pub const STATUS_CTX_INVALID_WD: NTSTATUS = NTSTATUS(-1073086418i32 as _);
pub const STATUS_CTX_LICENSE_CLIENT_INVALID: NTSTATUS = NTSTATUS(-1073086446i32 as _);
pub const STATUS_CTX_LICENSE_EXPIRED: NTSTATUS = NTSTATUS(-1073086444i32 as _);
pub const STATUS_CTX_LICENSE_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1073086445i32 as _);
pub const STATUS_CTX_LOGON_DISABLED: NTSTATUS = NTSTATUS(-1073086409i32 as _);
pub const STATUS_CTX_MODEM_INF_NOT_FOUND: NTSTATUS = NTSTATUS(-1073086456i32 as _);
pub const STATUS_CTX_MODEM_RESPONSE_BUSY: NTSTATUS = NTSTATUS(-1073086450i32 as _);
pub const STATUS_CTX_MODEM_RESPONSE_NO_CARRIER: NTSTATUS = NTSTATUS(-1073086452i32 as _);
pub const STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE: NTSTATUS = NTSTATUS(-1073086451i32 as _);
pub const STATUS_CTX_MODEM_RESPONSE_TIMEOUT: NTSTATUS = NTSTATUS(-1073086453i32 as _);
pub const STATUS_CTX_MODEM_RESPONSE_VOICE: NTSTATUS = NTSTATUS(-1073086449i32 as _);
pub const STATUS_CTX_NOT_CONSOLE: NTSTATUS = NTSTATUS(-1073086428i32 as _);
pub const STATUS_CTX_NO_OUTBUF: NTSTATUS = NTSTATUS(-1073086457i32 as _);
pub const STATUS_CTX_PD_NOT_FOUND: NTSTATUS = NTSTATUS(-1073086461i32 as _);
pub const STATUS_CTX_RESPONSE_ERROR: NTSTATUS = NTSTATUS(-1073086454i32 as _);
pub const STATUS_CTX_SECURITY_LAYER_ERROR: NTSTATUS = NTSTATUS(-1073086408i32 as _);
pub const STATUS_CTX_SHADOW_DENIED: NTSTATUS = NTSTATUS(-1073086422i32 as _);
pub const STATUS_CTX_SHADOW_DISABLED: NTSTATUS = NTSTATUS(-1073086415i32 as _);
pub const STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE: NTSTATUS = NTSTATUS(-1073086411i32 as _);
pub const STATUS_CTX_SHADOW_INVALID: NTSTATUS = NTSTATUS(-1073086416i32 as _);
pub const STATUS_CTX_SHADOW_NOT_RUNNING: NTSTATUS = NTSTATUS(-1073086410i32 as _);
pub const STATUS_CTX_TD_ERROR: NTSTATUS = NTSTATUS(-1073086448i32 as _);
pub const STATUS_CTX_WD_NOT_FOUND: NTSTATUS = NTSTATUS(-1073086417i32 as _);
pub const STATUS_CTX_WINSTATION_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1073086421i32 as _);
pub const STATUS_CTX_WINSTATION_BUSY: NTSTATUS = NTSTATUS(-1073086441i32 as _);
pub const STATUS_CTX_WINSTATION_NAME_COLLISION: NTSTATUS = NTSTATUS(-1073086442i32 as _);
pub const STATUS_CTX_WINSTATION_NAME_INVALID: NTSTATUS = NTSTATUS(-1073086463i32 as _);
pub const STATUS_CTX_WINSTATION_NOT_FOUND: NTSTATUS = NTSTATUS(-1073086443i32 as _);
pub const STATUS_CURRENT_DOMAIN_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1073741079i32 as _);
pub const STATUS_CURRENT_TRANSACTION_NOT_VALID: NTSTATUS = NTSTATUS(-1072103400i32 as _);
pub const STATUS_DATATYPE_MISALIGNMENT: NTSTATUS = NTSTATUS(-2147483646i32 as _);
pub const STATUS_DATATYPE_MISALIGNMENT_ERROR: NTSTATUS = NTSTATUS(-1073741115i32 as _);
pub const STATUS_DATA_CHECKSUM_ERROR: NTSTATUS = NTSTATUS(-1073740688i32 as _);
pub const STATUS_DATA_ERROR: NTSTATUS = NTSTATUS(-1073741762i32 as _);
pub const STATUS_DATA_LATE_ERROR: NTSTATUS = NTSTATUS(-1073741763i32 as _);
pub const STATUS_DATA_LOST_REPAIR: NTSTATUS = NTSTATUS(-2147481597i32 as _);
pub const STATUS_DATA_NOT_ACCEPTED: NTSTATUS = NTSTATUS(-1073741285i32 as _);
pub const STATUS_DATA_OVERRUN: NTSTATUS = NTSTATUS(-1073741764i32 as _);
pub const STATUS_DATA_OVERWRITTEN: NTSTATUS = NTSTATUS(304i32 as _);
pub const STATUS_DAX_MAPPING_EXISTS: NTSTATUS = NTSTATUS(-1073740644i32 as _);
pub const STATUS_DEBUGGER_INACTIVE: NTSTATUS = NTSTATUS(-1073740972i32 as _);
pub const STATUS_DEBUG_ATTACH_FAILED: NTSTATUS = NTSTATUS(-1073741287i32 as _);
pub const STATUS_DECRYPTION_FAILED: NTSTATUS = NTSTATUS(-1073741173i32 as _);
pub const STATUS_DELAY_LOAD_FAILED: NTSTATUS = NTSTATUS(-1073740782i32 as _);
pub const STATUS_DELETE_PENDING: NTSTATUS = NTSTATUS(-1073741738i32 as _);
pub const STATUS_DESTINATION_ELEMENT_FULL: NTSTATUS = NTSTATUS(-1073741180i32 as _);
pub const STATUS_DEVICE_ALREADY_ATTACHED: NTSTATUS = NTSTATUS(-1073741768i32 as _);
pub const STATUS_DEVICE_BUSY: NTSTATUS = NTSTATUS(-2147483631i32 as _);
pub const STATUS_DEVICE_CONFIGURATION_ERROR: NTSTATUS = NTSTATUS(-1073741438i32 as _);
pub const STATUS_DEVICE_DATA_ERROR: NTSTATUS = NTSTATUS(-1073741668i32 as _);
pub const STATUS_DEVICE_DOES_NOT_EXIST: NTSTATUS = NTSTATUS(-1073741632i32 as _);
pub const STATUS_DEVICE_DOOR_OPEN: NTSTATUS = NTSTATUS(-2147482999i32 as _);
pub const STATUS_DEVICE_ENUMERATION_ERROR: NTSTATUS = NTSTATUS(-1073740954i32 as _);
pub const STATUS_DEVICE_FEATURE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073740701i32 as _);
pub const STATUS_DEVICE_HARDWARE_ERROR: NTSTATUS = NTSTATUS(-1073740669i32 as _);
pub const STATUS_DEVICE_HINT_NAME_BUFFER_TOO_SMALL: NTSTATUS = NTSTATUS(-1073740650i32 as _);
pub const STATUS_DEVICE_HUNG: NTSTATUS = NTSTATUS(-1073740537i32 as _);
pub const STATUS_DEVICE_INSUFFICIENT_RESOURCES: NTSTATUS = NTSTATUS(-1073740696i32 as _);
pub const STATUS_DEVICE_IN_MAINTENANCE: NTSTATUS = NTSTATUS(-1073740647i32 as _);
pub const STATUS_DEVICE_NOT_CONNECTED: NTSTATUS = NTSTATUS(-1073741667i32 as _);
pub const STATUS_DEVICE_NOT_PARTITIONED: NTSTATUS = NTSTATUS(-1073741452i32 as _);
pub const STATUS_DEVICE_NOT_READY: NTSTATUS = NTSTATUS(-1073741661i32 as _);
pub const STATUS_DEVICE_OFF_LINE: NTSTATUS = NTSTATUS(-2147483632i32 as _);
pub const STATUS_DEVICE_PAPER_EMPTY: NTSTATUS = NTSTATUS(-2147483634i32 as _);
pub const STATUS_DEVICE_POWERED_OFF: NTSTATUS = NTSTATUS(-2147483633i32 as _);
pub const STATUS_DEVICE_POWER_CYCLE_REQUIRED: NTSTATUS = NTSTATUS(-2147483599i32 as _);
pub const STATUS_DEVICE_POWER_FAILURE: NTSTATUS = NTSTATUS(-1073741666i32 as _);
pub const STATUS_DEVICE_PROTOCOL_ERROR: NTSTATUS = NTSTATUS(-1073741434i32 as _);
pub const STATUS_DEVICE_REMOVED: NTSTATUS = NTSTATUS(-1073741130i32 as _);
pub const STATUS_DEVICE_REQUIRES_CLEANING: NTSTATUS = NTSTATUS(-2147483000i32 as _);
pub const STATUS_DEVICE_RESET_REQUIRED: NTSTATUS = NTSTATUS(-2147483210i32 as _);
pub const STATUS_DEVICE_SUPPORT_IN_PROGRESS: NTSTATUS = NTSTATUS(-2147483600i32 as _);
pub const STATUS_DEVICE_UNREACHABLE: NTSTATUS = NTSTATUS(-1073740700i32 as _);
pub const STATUS_DEVICE_UNRESPONSIVE: NTSTATUS = NTSTATUS(-1073740534i32 as _);
pub const STATUS_DFS_EXIT_PATH_FOUND: NTSTATUS = NTSTATUS(-1073741669i32 as _);
pub const STATUS_DFS_UNAVAILABLE: NTSTATUS = NTSTATUS(-1073741203i32 as _);
pub const STATUS_DIF_BINDING_API_NOT_FOUND: NTSTATUS = NTSTATUS(-1073738625i32 as _);
pub const STATUS_DIF_IOCALLBACK_NOT_REPLACED: NTSTATUS = NTSTATUS(-1073738634i32 as _);
pub const STATUS_DIF_LIVEDUMP_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1073738633i32 as _);
pub const STATUS_DIF_VOLATILE_DRIVER_HOTPATCHED: NTSTATUS = NTSTATUS(-1073738631i32 as _);
pub const STATUS_DIF_VOLATILE_DRIVER_IS_NOT_RUNNING: NTSTATUS = NTSTATUS(-1073738629i32 as _);
pub const STATUS_DIF_VOLATILE_INVALID_INFO: NTSTATUS = NTSTATUS(-1073738630i32 as _);
pub const STATUS_DIF_VOLATILE_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1073738626i32 as _);
pub const STATUS_DIF_VOLATILE_PLUGIN_CHANGE_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1073738627i32 as _);
pub const STATUS_DIF_VOLATILE_PLUGIN_IS_NOT_RUNNING: NTSTATUS = NTSTATUS(-1073738628i32 as _);
pub const STATUS_DIF_VOLATILE_SECTION_NOT_LOCKED: NTSTATUS = NTSTATUS(-1073738632i32 as _);
pub const STATUS_DIRECTORY_IS_A_REPARSE_POINT: NTSTATUS = NTSTATUS(-1073741183i32 as _);
pub const STATUS_DIRECTORY_NOT_EMPTY: NTSTATUS = NTSTATUS(-1073741567i32 as _);
pub const STATUS_DIRECTORY_NOT_RM: NTSTATUS = NTSTATUS(-1072103416i32 as _);
pub const STATUS_DIRECTORY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073740676i32 as _);
pub const STATUS_DIRECTORY_SERVICE_REQUIRED: NTSTATUS = NTSTATUS(-1073741135i32 as _);
pub const STATUS_DISK_CORRUPT_ERROR: NTSTATUS = NTSTATUS(-1073741774i32 as _);
pub const STATUS_DISK_FULL: NTSTATUS = NTSTATUS(-1073741697i32 as _);
pub const STATUS_DISK_OPERATION_FAILED: NTSTATUS = NTSTATUS(-1073741462i32 as _);
pub const STATUS_DISK_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1073739774i32 as _);
pub const STATUS_DISK_RECALIBRATE_FAILED: NTSTATUS = NTSTATUS(-1073741463i32 as _);
pub const STATUS_DISK_REPAIR_DISABLED: NTSTATUS = NTSTATUS(-1073739776i32 as _);
pub const STATUS_DISK_REPAIR_REDIRECTED: NTSTATUS = NTSTATUS(1073743879i32 as _);
pub const STATUS_DISK_REPAIR_UNSUCCESSFUL: NTSTATUS = NTSTATUS(-1073739768i32 as _);
pub const STATUS_DISK_RESET_FAILED: NTSTATUS = NTSTATUS(-1073741461i32 as _);
pub const STATUS_DISK_RESOURCES_EXHAUSTED: NTSTATUS = NTSTATUS(-1073740703i32 as _);
pub const STATUS_DLL_INIT_FAILED: NTSTATUS = NTSTATUS(-1073741502i32 as _);
pub const STATUS_DLL_INIT_FAILED_LOGOFF: NTSTATUS = NTSTATUS(-1073741205i32 as _);
pub const STATUS_DLL_MIGHT_BE_INCOMPATIBLE: NTSTATUS = NTSTATUS(-2147483604i32 as _);
pub const STATUS_DLL_MIGHT_BE_INSECURE: NTSTATUS = NTSTATUS(-2147483605i32 as _);
pub const STATUS_DLL_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741515i32 as _);
pub const STATUS_DOMAIN_CONTROLLER_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741261i32 as _);
pub const STATUS_DOMAIN_CTRLR_CONFIG_ERROR: NTSTATUS = NTSTATUS(-1073741474i32 as _);
pub const STATUS_DOMAIN_EXISTS: NTSTATUS = NTSTATUS(-1073741600i32 as _);
pub const STATUS_DOMAIN_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1073741599i32 as _);
pub const STATUS_DOMAIN_TRUST_INCONSISTENT: NTSTATUS = NTSTATUS(-1073741413i32 as _);
pub const STATUS_DRIVERS_LEAKING_LOCKED_PAGES: NTSTATUS = NTSTATUS(1073741869i32 as _);
pub const STATUS_DRIVER_BLOCKED: NTSTATUS = NTSTATUS(-1073740948i32 as _);
pub const STATUS_DRIVER_BLOCKED_CRITICAL: NTSTATUS = NTSTATUS(-1073740949i32 as _);
pub const STATUS_DRIVER_CANCEL_TIMEOUT: NTSTATUS = NTSTATUS(-1073741282i32 as _);
pub const STATUS_DRIVER_DATABASE_ERROR: NTSTATUS = NTSTATUS(-1073740947i32 as _);
pub const STATUS_DRIVER_ENTRYPOINT_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741213i32 as _);
pub const STATUS_DRIVER_FAILED_PRIOR_UNLOAD: NTSTATUS = NTSTATUS(-1073740914i32 as _);
pub const STATUS_DRIVER_FAILED_SLEEP: NTSTATUS = NTSTATUS(-1073741118i32 as _);
pub const STATUS_DRIVER_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1073741437i32 as _);
pub const STATUS_DRIVER_ORDINAL_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741214i32 as _);
pub const STATUS_DRIVER_PROCESS_TERMINATED: NTSTATUS = NTSTATUS(-1073740720i32 as _);
pub const STATUS_DRIVER_UNABLE_TO_LOAD: NTSTATUS = NTSTATUS(-1073741204i32 as _);
pub const STATUS_DS_ADMIN_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1073741119i32 as _);
pub const STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER: NTSTATUS = NTSTATUS(-1073740968i32 as _);
pub const STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS: NTSTATUS = NTSTATUS(-1073741148i32 as _);
pub const STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED: NTSTATUS = NTSTATUS(-1073741149i32 as _);
pub const STATUS_DS_BUSY: NTSTATUS = NTSTATUS(-1073741147i32 as _);
pub const STATUS_DS_CANT_MOD_OBJ_CLASS: NTSTATUS = NTSTATUS(-1073741138i32 as _);
pub const STATUS_DS_CANT_MOD_PRIMARYGROUPID: NTSTATUS = NTSTATUS(-1073741104i32 as _);
pub const STATUS_DS_CANT_ON_NON_LEAF: NTSTATUS = NTSTATUS(-1073741140i32 as _);
pub const STATUS_DS_CANT_ON_RDN: NTSTATUS = NTSTATUS(-1073741139i32 as _);
pub const STATUS_DS_CANT_START: NTSTATUS = NTSTATUS(-1073741087i32 as _);
pub const STATUS_DS_CROSS_DOM_MOVE_FAILED: NTSTATUS = NTSTATUS(-1073741137i32 as _);
pub const STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST: NTSTATUS = NTSTATUS(-1073740774i32 as _);
pub const STATUS_DS_DOMAIN_RENAME_IN_PROGRESS: NTSTATUS = NTSTATUS(-1073739775i32 as _);
pub const STATUS_DS_DUPLICATE_ID_FOUND: NTSTATUS = NTSTATUS(-1073740795i32 as _);
pub const STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST: NTSTATUS = NTSTATUS(-1073740773i32 as _);
pub const STATUS_DS_GC_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1073741136i32 as _);
pub const STATUS_DS_GC_REQUIRED: NTSTATUS = NTSTATUS(-1073741084i32 as _);
pub const STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER: NTSTATUS = NTSTATUS(-1073741094i32 as _);
pub const STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER: NTSTATUS = NTSTATUS(-1073741097i32 as _);
pub const STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER: NTSTATUS = NTSTATUS(-1073741096i32 as _);
pub const STATUS_DS_GROUP_CONVERSION_ERROR: NTSTATUS = NTSTATUS(-1073740794i32 as _);
pub const STATUS_DS_HAVE_PRIMARY_MEMBERS: NTSTATUS = NTSTATUS(-1073741092i32 as _);
pub const STATUS_DS_INCORRECT_ROLE_OWNER: NTSTATUS = NTSTATUS(-1073741143i32 as _);
pub const STATUS_DS_INIT_FAILURE: NTSTATUS = NTSTATUS(-1073741086i32 as _);
pub const STATUS_DS_INIT_FAILURE_CONSOLE: NTSTATUS = NTSTATUS(-1073741076i32 as _);
pub const STATUS_DS_INVALID_ATTRIBUTE_SYNTAX: NTSTATUS = NTSTATUS(-1073741150i32 as _);
pub const STATUS_DS_INVALID_GROUP_TYPE: NTSTATUS = NTSTATUS(-1073741100i32 as _);
pub const STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER: NTSTATUS = NTSTATUS(-1073741093i32 as _);
pub const STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY: NTSTATUS = NTSTATUS(-1073741083i32 as _);
pub const STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1073741081i32 as _);
pub const STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY: NTSTATUS = NTSTATUS(289i32 as _);
pub const STATUS_DS_NAME_NOT_UNIQUE: NTSTATUS = NTSTATUS(-1073740796i32 as _);
pub const STATUS_DS_NO_ATTRIBUTE_OR_VALUE: NTSTATUS = NTSTATUS(-1073741151i32 as _);
pub const STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS: NTSTATUS = NTSTATUS(-1073741082i32 as _);
pub const STATUS_DS_NO_MORE_RIDS: NTSTATUS = NTSTATUS(-1073741144i32 as _);
pub const STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN: NTSTATUS = NTSTATUS(-1073741099i32 as _);
pub const STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN: NTSTATUS = NTSTATUS(-1073741098i32 as _);
pub const STATUS_DS_NO_RIDS_ALLOCATED: NTSTATUS = NTSTATUS(-1073741145i32 as _);
pub const STATUS_DS_OBJ_CLASS_VIOLATION: NTSTATUS = NTSTATUS(-1073741141i32 as _);
pub const STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS: NTSTATUS = NTSTATUS(-1073700729i32 as _);
pub const STATUS_DS_OID_NOT_FOUND: NTSTATUS = NTSTATUS(-1073700728i32 as _);
pub const STATUS_DS_RIDMGR_DISABLED: NTSTATUS = NTSTATUS(-1073741126i32 as _);
pub const STATUS_DS_RIDMGR_INIT_ERROR: NTSTATUS = NTSTATUS(-1073741142i32 as _);
pub const STATUS_DS_SAM_INIT_FAILURE: NTSTATUS = NTSTATUS(-1073741109i32 as _);
pub const STATUS_DS_SAM_INIT_FAILURE_CONSOLE: NTSTATUS = NTSTATUS(-1073741075i32 as _);
pub const STATUS_DS_SENSITIVE_GROUP_VIOLATION: NTSTATUS = NTSTATUS(-1073741107i32 as _);
pub const STATUS_DS_SHUTTING_DOWN: NTSTATUS = NTSTATUS(1073742704i32 as _);
pub const STATUS_DS_SRC_SID_EXISTS_IN_FOREST: NTSTATUS = NTSTATUS(-1073740775i32 as _);
pub const STATUS_DS_UNAVAILABLE: NTSTATUS = NTSTATUS(-1073741146i32 as _);
pub const STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER: NTSTATUS = NTSTATUS(-1073741095i32 as _);
pub const STATUS_DS_VERSION_CHECK_FAILURE: NTSTATUS = NTSTATUS(-1073740971i32 as _);
pub const STATUS_DUPLICATE_NAME: NTSTATUS = NTSTATUS(-1073741635i32 as _);
pub const STATUS_DUPLICATE_OBJECTID: NTSTATUS = NTSTATUS(-1073741270i32 as _);
pub const STATUS_DUPLICATE_PRIVILEGES: NTSTATUS = NTSTATUS(-1073741402i32 as _);
pub const STATUS_DYNAMIC_CODE_BLOCKED: NTSTATUS = NTSTATUS(-1073740284i32 as _);
pub const STATUS_EAS_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073741745i32 as _);
pub const STATUS_EA_CORRUPT_ERROR: NTSTATUS = NTSTATUS(-1073741741i32 as _);
pub const STATUS_EA_LIST_INCONSISTENT: NTSTATUS = NTSTATUS(-2147483628i32 as _);
pub const STATUS_EA_TOO_LARGE: NTSTATUS = NTSTATUS(-1073741744i32 as _);
pub const STATUS_EFS_ALG_BLOB_TOO_BIG: NTSTATUS = NTSTATUS(-1073740974i32 as _);
pub const STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION: NTSTATUS = NTSTATUS(-1072103362i32 as _);
pub const STATUS_ELEVATION_REQUIRED: NTSTATUS = NTSTATUS(-1073740756i32 as _);
pub const STATUS_EMULATION_BREAKPOINT: NTSTATUS = NTSTATUS(1073741880i32 as _);
pub const STATUS_EMULATION_SYSCALL: NTSTATUS = NTSTATUS(1073741881i32 as _);
pub const STATUS_ENCLAVE_FAILURE: NTSTATUS = NTSTATUS(-1073740657i32 as _);
pub const STATUS_ENCLAVE_IS_TERMINATING: NTSTATUS = NTSTATUS(-1073740526i32 as _);
pub const STATUS_ENCLAVE_NOT_TERMINATED: NTSTATUS = NTSTATUS(-1073740527i32 as _);
pub const STATUS_ENCLAVE_VIOLATION: NTSTATUS = NTSTATUS(-1073740638i32 as _);
pub const STATUS_ENCOUNTERED_WRITE_IN_PROGRESS: NTSTATUS = NTSTATUS(-1073740749i32 as _);
pub const STATUS_ENCRYPTED_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073740605i32 as _);
pub const STATUS_ENCRYPTED_IO_NOT_POSSIBLE: NTSTATUS = NTSTATUS(-1073739760i32 as _);
pub const STATUS_ENCRYPTING_METADATA_DISALLOWED: NTSTATUS = NTSTATUS(-1073740617i32 as _);
pub const STATUS_ENCRYPTION_DISABLED: NTSTATUS = NTSTATUS(-1073740618i32 as _);
pub const STATUS_ENCRYPTION_FAILED: NTSTATUS = NTSTATUS(-1073741174i32 as _);
pub const STATUS_END_OF_FILE: NTSTATUS = NTSTATUS(-1073741807i32 as _);
pub const STATUS_END_OF_MEDIA: NTSTATUS = NTSTATUS(-2147483618i32 as _);
pub const STATUS_ENLISTMENT_NOT_FOUND: NTSTATUS = NTSTATUS(-1072103344i32 as _);
pub const STATUS_ENLISTMENT_NOT_SUPERIOR: NTSTATUS = NTSTATUS(-1072103373i32 as _);
pub const STATUS_ENTRYPOINT_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741511i32 as _);
pub const STATUS_EOF_ON_GHOSTED_RANGE: NTSTATUS = NTSTATUS(-1073700857i32 as _);
pub const STATUS_EOM_OVERFLOW: NTSTATUS = NTSTATUS(-1073741449i32 as _);
pub const STATUS_ERROR_PROCESS_NOT_IN_JOB: NTSTATUS = NTSTATUS(-1073741394i32 as _);
pub const STATUS_EVALUATION_EXPIRATION: NTSTATUS = NTSTATUS(-1073741208i32 as _);
pub const STATUS_EVENTLOG_CANT_START: NTSTATUS = NTSTATUS(-1073741425i32 as _);
pub const STATUS_EVENTLOG_FILE_CHANGED: NTSTATUS = NTSTATUS(-1073741417i32 as _);
pub const STATUS_EVENTLOG_FILE_CORRUPT: NTSTATUS = NTSTATUS(-1073741426i32 as _);
pub const STATUS_EVENT_DONE: NTSTATUS = NTSTATUS(1073741842i32 as _);
pub const STATUS_EVENT_PENDING: NTSTATUS = NTSTATUS(1073741843i32 as _);
pub const STATUS_EXECUTABLE_MEMORY_WRITE: NTSTATUS = NTSTATUS(-1073739997i32 as _);
pub const STATUS_EXPIRED_HANDLE: NTSTATUS = NTSTATUS(-1072103328i32 as _);
pub const STATUS_EXTERNAL_BACKING_PROVIDER_UNKNOWN: NTSTATUS = NTSTATUS(-1073740690i32 as _);
pub const STATUS_EXTERNAL_SYSKEY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073740639i32 as _);
pub const STATUS_EXTRANEOUS_INFORMATION: NTSTATUS = NTSTATUS(-2147483625i32 as _);
pub const STATUS_FAILED_DRIVER_ENTRY: NTSTATUS = NTSTATUS(-1073740955i32 as _);
pub const STATUS_FAILED_STACK_SWITCH: NTSTATUS = NTSTATUS(-1073740941i32 as _);
pub const STATUS_FAIL_CHECK: NTSTATUS = NTSTATUS(-1073741271i32 as _);
pub const STATUS_FAIL_FAST_EXCEPTION: NTSTATUS = NTSTATUS(-1073740286i32 as _);
pub const STATUS_FASTPATH_REJECTED: NTSTATUS = NTSTATUS(-1073700844i32 as _);
pub const STATUS_FATAL_APP_EXIT: NTSTATUS = NTSTATUS(1073741845i32 as _);
pub const STATUS_FATAL_MEMORY_EXHAUSTION: NTSTATUS = NTSTATUS(-1073741395i32 as _);
pub const STATUS_FATAL_USER_CALLBACK_EXCEPTION: NTSTATUS = NTSTATUS(-1073740771i32 as _);
pub const STATUS_FILEMARK_DETECTED: NTSTATUS = NTSTATUS(-2147483621i32 as _);
pub const STATUS_FILES_OPEN: NTSTATUS = NTSTATUS(-1073741561i32 as _);
pub const STATUS_FILE_CHECKED_OUT: NTSTATUS = NTSTATUS(-1073739519i32 as _);
pub const STATUS_FILE_CLOSED: NTSTATUS = NTSTATUS(-1073741528i32 as _);
pub const STATUS_FILE_CORRUPT_ERROR: NTSTATUS = NTSTATUS(-1073741566i32 as _);
pub const STATUS_FILE_DELETED: NTSTATUS = NTSTATUS(-1073741533i32 as _);
pub const STATUS_FILE_ENCRYPTED: NTSTATUS = NTSTATUS(-1073741165i32 as _);
pub const STATUS_FILE_FORCED_CLOSED: NTSTATUS = NTSTATUS(-1073741642i32 as _);
pub const STATUS_FILE_HANDLE_REVOKED: NTSTATUS = NTSTATUS(-1073739504i32 as _);
pub const STATUS_FILE_IDENTITY_NOT_PERSISTENT: NTSTATUS = NTSTATUS(-1072103370i32 as _);
pub const STATUS_FILE_INVALID: NTSTATUS = NTSTATUS(-1073741672i32 as _);
pub const STATUS_FILE_IS_A_DIRECTORY: NTSTATUS = NTSTATUS(-1073741638i32 as _);
pub const STATUS_FILE_IS_OFFLINE: NTSTATUS = NTSTATUS(-1073741209i32 as _);
pub const STATUS_FILE_LOCKED_WITH_ONLY_READERS: NTSTATUS = NTSTATUS(298i32 as _);
pub const STATUS_FILE_LOCKED_WITH_WRITERS: NTSTATUS = NTSTATUS(299i32 as _);
pub const STATUS_FILE_LOCK_CONFLICT: NTSTATUS = NTSTATUS(-1073741740i32 as _);
pub const STATUS_FILE_METADATA_OPTIMIZATION_IN_PROGRESS: NTSTATUS = NTSTATUS(-1073741397i32 as _);
pub const STATUS_FILE_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1073740697i32 as _);
pub const STATUS_FILE_NOT_ENCRYPTED: NTSTATUS = NTSTATUS(-1073741167i32 as _);
pub const STATUS_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073740620i32 as _);
pub const STATUS_FILE_PROTECTED_UNDER_DPL: NTSTATUS = NTSTATUS(-1073740637i32 as _);
pub const STATUS_FILE_RENAMED: NTSTATUS = NTSTATUS(-1073741611i32 as _);
pub const STATUS_FILE_SNAP_INVALID_PARAMETER: NTSTATUS = NTSTATUS(-1073679099i32 as _);
pub const STATUS_FILE_SNAP_IN_PROGRESS: NTSTATUS = NTSTATUS(-1073679104i32 as _);
pub const STATUS_FILE_SNAP_IO_NOT_COORDINATED: NTSTATUS = NTSTATUS(-1073679101i32 as _);
pub const STATUS_FILE_SNAP_MODIFY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073679102i32 as _);
pub const STATUS_FILE_SNAP_UNEXPECTED_ERROR: NTSTATUS = NTSTATUS(-1073679100i32 as _);
pub const STATUS_FILE_SNAP_USER_SECTION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073679103i32 as _);
pub const STATUS_FILE_SYSTEM_LIMITATION: NTSTATUS = NTSTATUS(-1073740761i32 as _);
pub const STATUS_FILE_SYSTEM_VIRTUALIZATION_BUSY: NTSTATUS = NTSTATUS(-1073689085i32 as _);
pub const STATUS_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION: NTSTATUS = NTSTATUS(-1073689083i32 as _);
pub const STATUS_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT: NTSTATUS = NTSTATUS(-1073689086i32 as _);
pub const STATUS_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN: NTSTATUS = NTSTATUS(-1073689084i32 as _);
pub const STATUS_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE: NTSTATUS = NTSTATUS(-1073689087i32 as _);
pub const STATUS_FILE_TOO_LARGE: NTSTATUS = NTSTATUS(-1073739516i32 as _);
pub const STATUS_FIRMWARE_IMAGE_INVALID: NTSTATUS = NTSTATUS(-1073740667i32 as _);
pub const STATUS_FIRMWARE_SLOT_INVALID: NTSTATUS = NTSTATUS(-1073740668i32 as _);
pub const STATUS_FIRMWARE_UPDATED: NTSTATUS = NTSTATUS(1073741868i32 as _);
pub const STATUS_FLOATED_SECTION: NTSTATUS = NTSTATUS(-1072103349i32 as _);
pub const STATUS_FLOAT_DENORMAL_OPERAND: NTSTATUS = NTSTATUS(-1073741683i32 as _);
pub const STATUS_FLOAT_DIVIDE_BY_ZERO: NTSTATUS = NTSTATUS(-1073741682i32 as _);
pub const STATUS_FLOAT_INEXACT_RESULT: NTSTATUS = NTSTATUS(-1073741681i32 as _);
pub const STATUS_FLOAT_INVALID_OPERATION: NTSTATUS = NTSTATUS(-1073741680i32 as _);
pub const STATUS_FLOAT_MULTIPLE_FAULTS: NTSTATUS = NTSTATUS(-1073741132i32 as _);
pub const STATUS_FLOAT_MULTIPLE_TRAPS: NTSTATUS = NTSTATUS(-1073741131i32 as _);
pub const STATUS_FLOAT_OVERFLOW: NTSTATUS = NTSTATUS(-1073741679i32 as _);
pub const STATUS_FLOAT_STACK_CHECK: NTSTATUS = NTSTATUS(-1073741678i32 as _);
pub const STATUS_FLOAT_UNDERFLOW: NTSTATUS = NTSTATUS(-1073741677i32 as _);
pub const STATUS_FLOPPY_BAD_REGISTERS: NTSTATUS = NTSTATUS(-1073741464i32 as _);
pub const STATUS_FLOPPY_ID_MARK_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741467i32 as _);
pub const STATUS_FLOPPY_UNKNOWN_ERROR: NTSTATUS = NTSTATUS(-1073741465i32 as _);
pub const STATUS_FLOPPY_VOLUME: NTSTATUS = NTSTATUS(-1073741468i32 as _);
pub const STATUS_FLOPPY_WRONG_CYLINDER: NTSTATUS = NTSTATUS(-1073741466i32 as _);
pub const STATUS_FLT_ALREADY_ENLISTED: NTSTATUS = NTSTATUS(-1071906789i32 as _);
pub const STATUS_FLT_BUFFER_TOO_SMALL: NTSTATUS = NTSTATUS(-2145648639i32 as _);
pub const STATUS_FLT_CBDQ_DISABLED: NTSTATUS = NTSTATUS(-1071906802i32 as _);
pub const STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND: NTSTATUS = NTSTATUS(-1071906794i32 as _);
pub const STATUS_FLT_CONTEXT_ALREADY_DEFINED: NTSTATUS = NTSTATUS(-1071906814i32 as _);
pub const STATUS_FLT_CONTEXT_ALREADY_LINKED: NTSTATUS = NTSTATUS(-1071906788i32 as _);
pub const STATUS_FLT_DELETING_OBJECT: NTSTATUS = NTSTATUS(-1071906805i32 as _);
pub const STATUS_FLT_DISALLOW_FAST_IO: NTSTATUS = NTSTATUS(-1071906812i32 as _);
pub const STATUS_FLT_DISALLOW_FSFILTER_IO: i32 = -1071906812i32;
pub const STATUS_FLT_DO_NOT_ATTACH: NTSTATUS = NTSTATUS(-1071906801i32 as _);
pub const STATUS_FLT_DO_NOT_DETACH: NTSTATUS = NTSTATUS(-1071906800i32 as _);
pub const STATUS_FLT_DUPLICATE_ENTRY: NTSTATUS = NTSTATUS(-1071906803i32 as _);
pub const STATUS_FLT_FILTER_NOT_FOUND: NTSTATUS = NTSTATUS(-1071906797i32 as _);
pub const STATUS_FLT_FILTER_NOT_READY: NTSTATUS = NTSTATUS(-1071906808i32 as _);
pub const STATUS_FLT_INSTANCE_ALTITUDE_COLLISION: NTSTATUS = NTSTATUS(-1071906799i32 as _);
pub const STATUS_FLT_INSTANCE_NAME_COLLISION: NTSTATUS = NTSTATUS(-1071906798i32 as _);
pub const STATUS_FLT_INSTANCE_NOT_FOUND: NTSTATUS = NTSTATUS(-1071906795i32 as _);
pub const STATUS_FLT_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1071906806i32 as _);
pub const STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST: NTSTATUS = NTSTATUS(-1071906813i32 as _);
pub const STATUS_FLT_INVALID_CONTEXT_REGISTRATION: NTSTATUS = NTSTATUS(-1071906793i32 as _);
pub const STATUS_FLT_INVALID_NAME_REQUEST: NTSTATUS = NTSTATUS(-1071906811i32 as _);
pub const STATUS_FLT_IO_COMPLETE: NTSTATUS = NTSTATUS(1835009i32 as _);
pub const STATUS_FLT_MUST_BE_NONPAGED_POOL: NTSTATUS = NTSTATUS(-1071906804i32 as _);
pub const STATUS_FLT_NAME_CACHE_MISS: NTSTATUS = NTSTATUS(-1071906792i32 as _);
pub const STATUS_FLT_NOT_INITIALIZED: NTSTATUS = NTSTATUS(-1071906809i32 as _);
pub const STATUS_FLT_NOT_SAFE_TO_POST_OPERATION: NTSTATUS = NTSTATUS(-1071906810i32 as _);
pub const STATUS_FLT_NO_DEVICE_OBJECT: NTSTATUS = NTSTATUS(-1071906791i32 as _);
pub const STATUS_FLT_NO_HANDLER_DEFINED: NTSTATUS = NTSTATUS(-1071906815i32 as _);
pub const STATUS_FLT_NO_WAITER_FOR_REPLY: NTSTATUS = NTSTATUS(-1071906784i32 as _);
pub const STATUS_FLT_POST_OPERATION_CLEANUP: NTSTATUS = NTSTATUS(-1071906807i32 as _);
pub const STATUS_FLT_REGISTRATION_BUSY: NTSTATUS = NTSTATUS(-1071906781i32 as _);
pub const STATUS_FLT_VOLUME_ALREADY_MOUNTED: NTSTATUS = NTSTATUS(-1071906790i32 as _);
pub const STATUS_FLT_VOLUME_NOT_FOUND: NTSTATUS = NTSTATUS(-1071906796i32 as _);
pub const STATUS_FLT_WCOS_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071906780i32 as _);
pub const STATUS_FORMS_AUTH_REQUIRED: NTSTATUS = NTSTATUS(-1073739515i32 as _);
pub const STATUS_FOUND_OUT_OF_SCOPE: NTSTATUS = NTSTATUS(-1073741266i32 as _);
pub const STATUS_FREE_SPACE_TOO_FRAGMENTED: NTSTATUS = NTSTATUS(-1073740645i32 as _);
pub const STATUS_FREE_VM_NOT_AT_BASE: NTSTATUS = NTSTATUS(-1073741665i32 as _);
pub const STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY: NTSTATUS = NTSTATUS(294i32 as _);
pub const STATUS_FS_DRIVER_REQUIRED: NTSTATUS = NTSTATUS(-1073741412i32 as _);
pub const STATUS_FT_DI_SCAN_REQUIRED: NTSTATUS = NTSTATUS(-1073740692i32 as _);
pub const STATUS_FT_MISSING_MEMBER: NTSTATUS = NTSTATUS(-1073741473i32 as _);
pub const STATUS_FT_ORPHANING: NTSTATUS = NTSTATUS(-1073741459i32 as _);
pub const STATUS_FT_READ_FAILURE: NTSTATUS = NTSTATUS(-1073740629i32 as _);
pub const STATUS_FT_READ_FROM_COPY: NTSTATUS = NTSTATUS(1073741877i32 as _);
pub const STATUS_FT_READ_FROM_COPY_FAILURE: NTSTATUS = NTSTATUS(-1073740609i32 as _);
pub const STATUS_FT_READ_RECOVERY_FROM_BACKUP: NTSTATUS = NTSTATUS(1073741834i32 as _);
pub const STATUS_FT_WRITE_FAILURE: NTSTATUS = NTSTATUS(-1073740693i32 as _);
pub const STATUS_FT_WRITE_RECOVERY: NTSTATUS = NTSTATUS(1073741835i32 as _);
pub const STATUS_FULLSCREEN_MODE: NTSTATUS = NTSTATUS(-1073741479i32 as _);
pub const STATUS_FVE_ACTION_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1071579127i32 as _);
pub const STATUS_FVE_AUTH_INVALID_APPLICATION: NTSTATUS = NTSTATUS(-1071579109i32 as _);
pub const STATUS_FVE_AUTH_INVALID_CONFIG: NTSTATUS = NTSTATUS(-1071579108i32 as _);
pub const STATUS_FVE_BAD_DATA: NTSTATUS = NTSTATUS(-1071579126i32 as _);
pub const STATUS_FVE_BAD_INFORMATION: NTSTATUS = NTSTATUS(-1071579134i32 as _);
pub const STATUS_FVE_BAD_METADATA_POINTER: NTSTATUS = NTSTATUS(-1071579105i32 as _);
pub const STATUS_FVE_BAD_PARTITION_SIZE: NTSTATUS = NTSTATUS(-1071579131i32 as _);
pub const STATUS_FVE_CONV_READ_ERROR: NTSTATUS = NTSTATUS(-1071579123i32 as _);
pub const STATUS_FVE_CONV_RECOVERY_FAILED: NTSTATUS = NTSTATUS(-1071579096i32 as _);
pub const STATUS_FVE_CONV_WRITE_ERROR: NTSTATUS = NTSTATUS(-1071579122i32 as _);
pub const STATUS_FVE_DEBUGGER_ENABLED: NTSTATUS = NTSTATUS(-1071579107i32 as _);
pub const STATUS_FVE_DEVICE_LOCKEDOUT: NTSTATUS = NTSTATUS(-1071579077i32 as _);
pub const STATUS_FVE_DRY_RUN_FAILED: NTSTATUS = NTSTATUS(-1071579106i32 as _);
pub const STATUS_FVE_EDRIVE_BAND_ENUMERATION_FAILED: NTSTATUS = NTSTATUS(-1071579071i32 as _);
pub const STATUS_FVE_EDRIVE_DRY_RUN_FAILED: NTSTATUS = NTSTATUS(-1071579080i32 as _);
pub const STATUS_FVE_ENH_PIN_INVALID: NTSTATUS = NTSTATUS(-1071579087i32 as _);
pub const STATUS_FVE_FAILED_AUTHENTICATION: NTSTATUS = NTSTATUS(-1071579119i32 as _);
pub const STATUS_FVE_FAILED_SECTOR_SIZE: NTSTATUS = NTSTATUS(-1071579120i32 as _);
pub const STATUS_FVE_FAILED_WRONG_FS: NTSTATUS = NTSTATUS(-1071579132i32 as _);
pub const STATUS_FVE_FS_MOUNTED: NTSTATUS = NTSTATUS(-1071579129i32 as _);
pub const STATUS_FVE_FS_NOT_EXTENDED: NTSTATUS = NTSTATUS(-1071579130i32 as _);
pub const STATUS_FVE_FULL_ENCRYPTION_NOT_ALLOWED_ON_TP_STORAGE: NTSTATUS = NTSTATUS(-1071579086i32 as _);
pub const STATUS_FVE_INVALID_DATUM_TYPE: NTSTATUS = NTSTATUS(-1071579094i32 as _);
pub const STATUS_FVE_KEYFILE_INVALID: NTSTATUS = NTSTATUS(-1071579116i32 as _);
pub const STATUS_FVE_KEYFILE_NOT_FOUND: NTSTATUS = NTSTATUS(-1071579117i32 as _);
pub const STATUS_FVE_KEYFILE_NO_VMK: NTSTATUS = NTSTATUS(-1071579115i32 as _);
pub const STATUS_FVE_LOCKED_VOLUME: NTSTATUS = NTSTATUS(-1071579136i32 as _);
pub const STATUS_FVE_MOR_FAILED: NTSTATUS = NTSTATUS(-1071579099i32 as _);
pub const STATUS_FVE_NOT_ALLOWED_ON_CLUSTER: NTSTATUS = NTSTATUS(-1071579083i32 as _);
pub const STATUS_FVE_NOT_ALLOWED_ON_CSV_STACK: NTSTATUS = NTSTATUS(-1071579084i32 as _);
pub const STATUS_FVE_NOT_ALLOWED_TO_UPGRADE_WHILE_CONVERTING: NTSTATUS = NTSTATUS(-1071579082i32 as _);
pub const STATUS_FVE_NOT_DATA_VOLUME: NTSTATUS = NTSTATUS(-1071579124i32 as _);
pub const STATUS_FVE_NOT_DE_VOLUME: NTSTATUS = NTSTATUS(-1071579075i32 as _);
pub const STATUS_FVE_NOT_ENCRYPTED: NTSTATUS = NTSTATUS(-1071579135i32 as _);
pub const STATUS_FVE_NOT_OS_VOLUME: NTSTATUS = NTSTATUS(-1071579118i32 as _);
pub const STATUS_FVE_NO_AUTOUNLOCK_MASTER_KEY: NTSTATUS = NTSTATUS(-1071579100i32 as _);
pub const STATUS_FVE_NO_FEATURE_LICENSE: NTSTATUS = NTSTATUS(-1071579098i32 as _);
pub const STATUS_FVE_NO_LICENSE: NTSTATUS = NTSTATUS(-1071579128i32 as _);
pub const STATUS_FVE_OLD_METADATA_COPY: NTSTATUS = NTSTATUS(-1071579104i32 as _);
pub const STATUS_FVE_OSV_KSR_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1071579072i32 as _);
pub const STATUS_FVE_OVERLAPPED_UPDATE: NTSTATUS = NTSTATUS(-1071579121i32 as _);
pub const STATUS_FVE_PARTIAL_METADATA: NTSTATUS = NTSTATUS(-2145320959i32 as _);
pub const STATUS_FVE_PIN_INVALID: NTSTATUS = NTSTATUS(-1071579110i32 as _);
pub const STATUS_FVE_POLICY_USER_DISABLE_RDV_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1071579097i32 as _);
pub const STATUS_FVE_PROTECTION_CANNOT_BE_DISABLED: NTSTATUS = NTSTATUS(-1071579073i32 as _);
pub const STATUS_FVE_PROTECTION_DISABLED: NTSTATUS = NTSTATUS(-1071579074i32 as _);
pub const STATUS_FVE_RAW_ACCESS: NTSTATUS = NTSTATUS(-1071579102i32 as _);
pub const STATUS_FVE_RAW_BLOCKED: NTSTATUS = NTSTATUS(-1071579101i32 as _);
pub const STATUS_FVE_REBOOT_REQUIRED: NTSTATUS = NTSTATUS(-1071579103i32 as _);
pub const STATUS_FVE_SECUREBOOT_CONFIG_CHANGE: NTSTATUS = NTSTATUS(-1071579078i32 as _);
pub const STATUS_FVE_SECUREBOOT_DISABLED: NTSTATUS = NTSTATUS(-1071579079i32 as _);
pub const STATUS_FVE_TOO_SMALL: NTSTATUS = NTSTATUS(-1071579133i32 as _);
pub const STATUS_FVE_TPM_DISABLED: NTSTATUS = NTSTATUS(-1071579114i32 as _);
pub const STATUS_FVE_TPM_INVALID_PCR: NTSTATUS = NTSTATUS(-1071579112i32 as _);
pub const STATUS_FVE_TPM_NO_VMK: NTSTATUS = NTSTATUS(-1071579111i32 as _);
pub const STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO: NTSTATUS = NTSTATUS(-1071579113i32 as _);
pub const STATUS_FVE_TRANSIENT_STATE: NTSTATUS = NTSTATUS(-2145320958i32 as _);
pub const STATUS_FVE_VIRTUALIZED_SPACE_TOO_BIG: NTSTATUS = NTSTATUS(-1071579095i32 as _);
pub const STATUS_FVE_VOLUME_EXTEND_PREVENTS_EOW_DECRYPT: NTSTATUS = NTSTATUS(-1071579076i32 as _);
pub const STATUS_FVE_VOLUME_NOT_BOUND: NTSTATUS = NTSTATUS(-1071579125i32 as _);
pub const STATUS_FVE_VOLUME_TOO_SMALL: NTSTATUS = NTSTATUS(-1071579088i32 as _);
pub const STATUS_FVE_WIPE_CANCEL_NOT_APPLICABLE: NTSTATUS = NTSTATUS(-1071579081i32 as _);
pub const STATUS_FVE_WIPE_NOT_ALLOWED_ON_TP_STORAGE: NTSTATUS = NTSTATUS(-1071579085i32 as _);
pub const STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER: NTSTATUS = NTSTATUS(-1071513556i32 as _);
pub const STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER: NTSTATUS = NTSTATUS(-1071513555i32 as _);
pub const STATUS_FWP_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1071513591i32 as _);
pub const STATUS_FWP_BUILTIN_OBJECT: NTSTATUS = NTSTATUS(-1071513577i32 as _);
pub const STATUS_FWP_CALLOUT_NOTIFICATION_FAILED: NTSTATUS = NTSTATUS(-1071513545i32 as _);
pub const STATUS_FWP_CALLOUT_NOT_FOUND: NTSTATUS = NTSTATUS(-1071513599i32 as _);
pub const STATUS_FWP_CANNOT_PEND: NTSTATUS = NTSTATUS(-1071513341i32 as _);
pub const STATUS_FWP_CONDITION_NOT_FOUND: NTSTATUS = NTSTATUS(-1071513598i32 as _);
pub const STATUS_FWP_CONNECTIONS_DISABLED: NTSTATUS = NTSTATUS(-1071513535i32 as _);
pub const STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT: NTSTATUS = NTSTATUS(-1071513553i32 as _);
pub const STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER: NTSTATUS = NTSTATUS(-1071513554i32 as _);
pub const STATUS_FWP_DROP_NOICMP: NTSTATUS = NTSTATUS(-1071513340i32 as _);
pub const STATUS_FWP_DUPLICATE_AUTH_METHOD: NTSTATUS = NTSTATUS(-1071513540i32 as _);
pub const STATUS_FWP_DUPLICATE_CONDITION: NTSTATUS = NTSTATUS(-1071513558i32 as _);
pub const STATUS_FWP_DUPLICATE_KEYMOD: NTSTATUS = NTSTATUS(-1071513557i32 as _);
pub const STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS: NTSTATUS = NTSTATUS(-1071513589i32 as _);
pub const STATUS_FWP_EM_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071513550i32 as _);
pub const STATUS_FWP_FILTER_NOT_FOUND: NTSTATUS = NTSTATUS(-1071513597i32 as _);
pub const STATUS_FWP_IKEEXT_NOT_RUNNING: NTSTATUS = NTSTATUS(-1071513532i32 as _);
pub const STATUS_FWP_INCOMPATIBLE_AUTH_METHOD: NTSTATUS = NTSTATUS(-1071513552i32 as _);
pub const STATUS_FWP_INCOMPATIBLE_CIPHER_TRANSFORM: NTSTATUS = NTSTATUS(-1071513542i32 as _);
pub const STATUS_FWP_INCOMPATIBLE_DH_GROUP: NTSTATUS = NTSTATUS(-1071513551i32 as _);
pub const STATUS_FWP_INCOMPATIBLE_LAYER: NTSTATUS = NTSTATUS(-1071513580i32 as _);
pub const STATUS_FWP_INCOMPATIBLE_SA_STATE: NTSTATUS = NTSTATUS(-1071513573i32 as _);
pub const STATUS_FWP_INCOMPATIBLE_TXN: NTSTATUS = NTSTATUS(-1071513583i32 as _);
pub const STATUS_FWP_INJECT_HANDLE_CLOSING: NTSTATUS = NTSTATUS(-1071513343i32 as _);
pub const STATUS_FWP_INJECT_HANDLE_STALE: NTSTATUS = NTSTATUS(-1071513342i32 as _);
pub const STATUS_FWP_INVALID_ACTION_TYPE: NTSTATUS = NTSTATUS(-1071513564i32 as _);
pub const STATUS_FWP_INVALID_AUTH_TRANSFORM: NTSTATUS = NTSTATUS(-1071513544i32 as _);
pub const STATUS_FWP_INVALID_CIPHER_TRANSFORM: NTSTATUS = NTSTATUS(-1071513543i32 as _);
pub const STATUS_FWP_INVALID_DNS_NAME: NTSTATUS = NTSTATUS(-1071513534i32 as _);
pub const STATUS_FWP_INVALID_ENUMERATOR: NTSTATUS = NTSTATUS(-1071513571i32 as _);
pub const STATUS_FWP_INVALID_FLAGS: NTSTATUS = NTSTATUS(-1071513570i32 as _);
pub const STATUS_FWP_INVALID_INTERVAL: NTSTATUS = NTSTATUS(-1071513567i32 as _);
pub const STATUS_FWP_INVALID_NET_MASK: NTSTATUS = NTSTATUS(-1071513569i32 as _);
pub const STATUS_FWP_INVALID_PARAMETER: NTSTATUS = NTSTATUS(-1071513547i32 as _);
pub const STATUS_FWP_INVALID_RANGE: NTSTATUS = NTSTATUS(-1071513568i32 as _);
pub const STATUS_FWP_INVALID_TRANSFORM_COMBINATION: NTSTATUS = NTSTATUS(-1071513541i32 as _);
pub const STATUS_FWP_INVALID_TUNNEL_ENDPOINT: NTSTATUS = NTSTATUS(-1071513539i32 as _);
pub const STATUS_FWP_INVALID_WEIGHT: NTSTATUS = NTSTATUS(-1071513563i32 as _);
pub const STATUS_FWP_IN_USE: NTSTATUS = NTSTATUS(-1071513590i32 as _);
pub const STATUS_FWP_KEY_DICTATION_INVALID_KEYING_MATERIAL: NTSTATUS = NTSTATUS(-1071513536i32 as _);
pub const STATUS_FWP_KEY_DICTATOR_ALREADY_REGISTERED: NTSTATUS = NTSTATUS(-1071513537i32 as _);
pub const STATUS_FWP_KM_CLIENTS_ONLY: NTSTATUS = NTSTATUS(-1071513579i32 as _);
pub const STATUS_FWP_L2_DRIVER_NOT_READY: NTSTATUS = NTSTATUS(-1071513538i32 as _);
pub const STATUS_FWP_LAYER_NOT_FOUND: NTSTATUS = NTSTATUS(-1071513596i32 as _);
pub const STATUS_FWP_LIFETIME_MISMATCH: NTSTATUS = NTSTATUS(-1071513578i32 as _);
pub const STATUS_FWP_MATCH_TYPE_MISMATCH: NTSTATUS = NTSTATUS(-1071513562i32 as _);
pub const STATUS_FWP_NET_EVENTS_DISABLED: NTSTATUS = NTSTATUS(-1071513581i32 as _);
pub const STATUS_FWP_NEVER_MATCH: NTSTATUS = NTSTATUS(-1071513549i32 as _);
pub const STATUS_FWP_NOTIFICATION_DROPPED: NTSTATUS = NTSTATUS(-1071513575i32 as _);
pub const STATUS_FWP_NOT_FOUND: NTSTATUS = NTSTATUS(-1071513592i32 as _);
pub const STATUS_FWP_NO_TXN_IN_PROGRESS: NTSTATUS = NTSTATUS(-1071513587i32 as _);
pub const STATUS_FWP_NULL_DISPLAY_NAME: NTSTATUS = NTSTATUS(-1071513565i32 as _);
pub const STATUS_FWP_NULL_POINTER: NTSTATUS = NTSTATUS(-1071513572i32 as _);
pub const STATUS_FWP_OUT_OF_BOUNDS: NTSTATUS = NTSTATUS(-1071513560i32 as _);
pub const STATUS_FWP_PROVIDER_CONTEXT_MISMATCH: NTSTATUS = NTSTATUS(-1071513548i32 as _);
pub const STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND: NTSTATUS = NTSTATUS(-1071513594i32 as _);
pub const STATUS_FWP_PROVIDER_NOT_FOUND: NTSTATUS = NTSTATUS(-1071513595i32 as _);
pub const STATUS_FWP_RESERVED: NTSTATUS = NTSTATUS(-1071513559i32 as _);
pub const STATUS_FWP_SESSION_ABORTED: NTSTATUS = NTSTATUS(-1071513584i32 as _);
pub const STATUS_FWP_STILL_ON: NTSTATUS = NTSTATUS(-1071513533i32 as _);
pub const STATUS_FWP_SUBLAYER_NOT_FOUND: NTSTATUS = NTSTATUS(-1071513593i32 as _);
pub const STATUS_FWP_TCPIP_NOT_READY: NTSTATUS = NTSTATUS(-1071513344i32 as _);
pub const STATUS_FWP_TIMEOUT: NTSTATUS = NTSTATUS(-1071513582i32 as _);
pub const STATUS_FWP_TOO_MANY_CALLOUTS: NTSTATUS = NTSTATUS(-1071513576i32 as _);
pub const STATUS_FWP_TOO_MANY_SUBLAYERS: NTSTATUS = NTSTATUS(-1071513546i32 as _);
pub const STATUS_FWP_TRAFFIC_MISMATCH: NTSTATUS = NTSTATUS(-1071513574i32 as _);
pub const STATUS_FWP_TXN_ABORTED: NTSTATUS = NTSTATUS(-1071513585i32 as _);
pub const STATUS_FWP_TXN_IN_PROGRESS: NTSTATUS = NTSTATUS(-1071513586i32 as _);
pub const STATUS_FWP_TYPE_MISMATCH: NTSTATUS = NTSTATUS(-1071513561i32 as _);
pub const STATUS_FWP_WRONG_SESSION: NTSTATUS = NTSTATUS(-1071513588i32 as _);
pub const STATUS_FWP_ZERO_LENGTH_ARRAY: NTSTATUS = NTSTATUS(-1071513566i32 as _);
pub const STATUS_GDI_HANDLE_LEAK: NTSTATUS = NTSTATUS(-2143354879i32 as _);
pub const STATUS_GENERIC_COMMAND_FAILED: NTSTATUS = NTSTATUS(-1072365530i32 as _);
pub const STATUS_GENERIC_NOT_MAPPED: NTSTATUS = NTSTATUS(-1073741594i32 as _);
pub const STATUS_GHOSTED: NTSTATUS = NTSTATUS(303i32 as _);
pub const STATUS_GPIO_CLIENT_INFORMATION_INVALID: NTSTATUS = NTSTATUS(-1073700574i32 as _);
pub const STATUS_GPIO_INCOMPATIBLE_CONNECT_MODE: NTSTATUS = NTSTATUS(-1073700570i32 as _);
pub const STATUS_GPIO_INTERRUPT_ALREADY_UNMASKED: NTSTATUS = NTSTATUS(-2147442393i32 as _);
pub const STATUS_GPIO_INVALID_REGISTRATION_PACKET: NTSTATUS = NTSTATUS(-1073700572i32 as _);
pub const STATUS_GPIO_OPERATION_DENIED: NTSTATUS = NTSTATUS(-1073700571i32 as _);
pub const STATUS_GPIO_VERSION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073700573i32 as _);
pub const STATUS_GRACEFUL_DISCONNECT: NTSTATUS = NTSTATUS(-1073741257i32 as _);
pub const STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED: NTSTATUS = NTSTATUS(-1071774661i32 as _);
pub const STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY: NTSTATUS = NTSTATUS(-1071774669i32 as _);
pub const STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE: NTSTATUS = NTSTATUS(-1071774936i32 as _);
pub const STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET: NTSTATUS = NTSTATUS(-1071774935i32 as _);
pub const STATUS_GRAPHICS_ADAPTER_WAS_RESET: NTSTATUS = NTSTATUS(-1071775741i32 as _);
pub const STATUS_GRAPHICS_ALLOCATION_BUSY: NTSTATUS = NTSTATUS(-1071775486i32 as _);
pub const STATUS_GRAPHICS_ALLOCATION_CLOSED: NTSTATUS = NTSTATUS(-1071775470i32 as _);
pub const STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST: NTSTATUS = NTSTATUS(-1071775466i32 as _);
pub const STATUS_GRAPHICS_ALLOCATION_INVALID: NTSTATUS = NTSTATUS(-1071775482i32 as _);
pub const STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION: NTSTATUS = NTSTATUS(-1071774886i32 as _);
pub const STATUS_GRAPHICS_CANNOTCOLORCONVERT: NTSTATUS = NTSTATUS(-1071775736i32 as _);
pub const STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN: NTSTATUS = NTSTATUS(-1071774909i32 as _);
pub const STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION: NTSTATUS = NTSTATUS(-1071775479i32 as _);
pub const STATUS_GRAPHICS_CANT_LOCK_MEMORY: NTSTATUS = NTSTATUS(-1071775487i32 as _);
pub const STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION: NTSTATUS = NTSTATUS(-1071775471i32 as _);
pub const STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED: NTSTATUS = NTSTATUS(-1071774670i32 as _);
pub const STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON: NTSTATUS = NTSTATUS(-1071774667i32 as _);
pub const STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED: NTSTATUS = NTSTATUS(-1071774668i32 as _);
pub const STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774719i32 as _);
pub const STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET: NTSTATUS = NTSTATUS(-1071774884i32 as _);
pub const STATUS_GRAPHICS_COPP_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774463i32 as _);
pub const STATUS_GRAPHICS_DATASET_IS_EMPTY: NTSTATUS = NTSTATUS(1075708747i32 as _);
pub const STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING: NTSTATUS = NTSTATUS(-1071774329i32 as _);
pub const STATUS_GRAPHICS_DDCCI_INVALID_DATA: NTSTATUS = NTSTATUS(-1071774331i32 as _);
pub const STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM: NTSTATUS = NTSTATUS(-1071774325i32 as _);
pub const STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND: NTSTATUS = NTSTATUS(-1071774327i32 as _);
pub const STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH: NTSTATUS = NTSTATUS(-1071774326i32 as _);
pub const STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE: NTSTATUS = NTSTATUS(-1071774330i32 as _);
pub const STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774332i32 as _);
pub const STATUS_GRAPHICS_DEPENDABLE_CHILD_STATUS: NTSTATUS = NTSTATUS(1075708988i32 as _);
pub const STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP: NTSTATUS = NTSTATUS(-1071774238i32 as _);
pub const STATUS_GRAPHICS_DRIVER_MISMATCH: NTSTATUS = NTSTATUS(-1071775735i32 as _);
pub const STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION: NTSTATUS = NTSTATUS(-1071774939i32 as _);
pub const STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET: NTSTATUS = NTSTATUS(-1071774945i32 as _);
pub const STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET: NTSTATUS = NTSTATUS(-1071774947i32 as _);
pub const STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774904i32 as _);
pub const STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE: NTSTATUS = NTSTATUS(-1071775232i32 as _);
pub const STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST: NTSTATUS = NTSTATUS(-1071774335i32 as _);
pub const STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA: NTSTATUS = NTSTATUS(-1071774333i32 as _);
pub const STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA: NTSTATUS = NTSTATUS(-1071774334i32 as _);
pub const STATUS_GRAPHICS_I2C_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774336i32 as _);
pub const STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT: NTSTATUS = NTSTATUS(-1071774891i32 as _);
pub const STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE: NTSTATUS = NTSTATUS(-1071774666i32 as _);
pub const STATUS_GRAPHICS_INDIRECT_DISPLAY_ABANDON_SWAPCHAIN: NTSTATUS = NTSTATUS(-1071775726i32 as _);
pub const STATUS_GRAPHICS_INDIRECT_DISPLAY_DEVICE_STOPPED: NTSTATUS = NTSTATUS(-1071775725i32 as _);
pub const STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER: NTSTATUS = NTSTATUS(-1071775743i32 as _);
pub const STATUS_GRAPHICS_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1071774233i32 as _);
pub const STATUS_GRAPHICS_INVALID_ACTIVE_REGION: NTSTATUS = NTSTATUS(-1071774965i32 as _);
pub const STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE: NTSTATUS = NTSTATUS(-1071775468i32 as _);
pub const STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE: NTSTATUS = NTSTATUS(-1071775469i32 as _);
pub const STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE: NTSTATUS = NTSTATUS(-1071775472i32 as _);
pub const STATUS_GRAPHICS_INVALID_CLIENT_TYPE: NTSTATUS = NTSTATUS(-1071774885i32 as _);
pub const STATUS_GRAPHICS_INVALID_COLORBASIS: NTSTATUS = NTSTATUS(-1071774914i32 as _);
pub const STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE: NTSTATUS = NTSTATUS(-1071774897i32 as _);
pub const STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER: NTSTATUS = NTSTATUS(-1071775742i32 as _);
pub const STATUS_GRAPHICS_INVALID_DRIVER_MODEL: NTSTATUS = NTSTATUS(-1071775740i32 as _);
pub const STATUS_GRAPHICS_INVALID_FREQUENCY: NTSTATUS = NTSTATUS(-1071774966i32 as _);
pub const STATUS_GRAPHICS_INVALID_GAMMA_RAMP: NTSTATUS = NTSTATUS(-1071774905i32 as _);
pub const STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM: NTSTATUS = NTSTATUS(-1071774890i32 as _);
pub const STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR: NTSTATUS = NTSTATUS(-1071774933i32 as _);
pub const STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET: NTSTATUS = NTSTATUS(-1071774934i32 as _);
pub const STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN: NTSTATUS = NTSTATUS(-1071774889i32 as _);
pub const STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE: NTSTATUS = NTSTATUS(-1071774948i32 as _);
pub const STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET: NTSTATUS = NTSTATUS(-1071774949i32 as _);
pub const STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT: NTSTATUS = NTSTATUS(-1071774888i32 as _);
pub const STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET: NTSTATUS = NTSTATUS(-1071774943i32 as _);
pub const STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE: NTSTATUS = NTSTATUS(-1071774942i32 as _);
pub const STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION: NTSTATUS = NTSTATUS(-1071774907i32 as _);
pub const STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE: NTSTATUS = NTSTATUS(-1071774898i32 as _);
pub const STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL: NTSTATUS = NTSTATUS(-1071774908i32 as _);
pub const STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE: NTSTATUS = NTSTATUS(-1071774324i32 as _);
pub const STATUS_GRAPHICS_INVALID_PIXELFORMAT: NTSTATUS = NTSTATUS(-1071774915i32 as _);
pub const STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE: NTSTATUS = NTSTATUS(-1071774913i32 as _);
pub const STATUS_GRAPHICS_INVALID_POINTER: NTSTATUS = NTSTATUS(-1071774236i32 as _);
pub const STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE: NTSTATUS = NTSTATUS(-1071774918i32 as _);
pub const STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING: NTSTATUS = NTSTATUS(-1071774894i32 as _);
pub const STATUS_GRAPHICS_INVALID_STRIDE: NTSTATUS = NTSTATUS(-1071774916i32 as _);
pub const STATUS_GRAPHICS_INVALID_TOTAL_REGION: NTSTATUS = NTSTATUS(-1071774964i32 as _);
pub const STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET: NTSTATUS = NTSTATUS(-1071774955i32 as _);
pub const STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET: NTSTATUS = NTSTATUS(-1071774954i32 as _);
pub const STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE: NTSTATUS = NTSTATUS(-1071774972i32 as _);
pub const STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE: NTSTATUS = NTSTATUS(-1071774960i32 as _);
pub const STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET: NTSTATUS = NTSTATUS(-1071774971i32 as _);
pub const STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE: NTSTATUS = NTSTATUS(-1071774959i32 as _);
pub const STATUS_GRAPHICS_INVALID_VIDPN: NTSTATUS = NTSTATUS(-1071774973i32 as _);
pub const STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH: NTSTATUS = NTSTATUS(-1071774951i32 as _);
pub const STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET: NTSTATUS = NTSTATUS(-1071774968i32 as _);
pub const STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET: NTSTATUS = NTSTATUS(-1071774967i32 as _);
pub const STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE: NTSTATUS = NTSTATUS(-1071774929i32 as _);
pub const STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY: NTSTATUS = NTSTATUS(-1071774976i32 as _);
pub const STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON: NTSTATUS = NTSTATUS(-1071774899i32 as _);
pub const STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE: NTSTATUS = NTSTATUS(-1071774917i32 as _);
pub const STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED: NTSTATUS = NTSTATUS(-1071774671i32 as _);
pub const STATUS_GRAPHICS_LEADLINK_START_DEFERRED: NTSTATUS = NTSTATUS(1075708983i32 as _);
pub const STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED: NTSTATUS = NTSTATUS(-1071774887i32 as _);
pub const STATUS_GRAPHICS_MCA_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1071774328i32 as _);
pub const STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774237i32 as _);
pub const STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET: NTSTATUS = NTSTATUS(-1071774956i32 as _);
pub const STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE: NTSTATUS = NTSTATUS(-1071774940i32 as _);
pub const STATUS_GRAPHICS_MODE_NOT_IN_MODESET: NTSTATUS = NTSTATUS(-1071774902i32 as _);
pub const STATUS_GRAPHICS_MODE_NOT_PINNED: NTSTATUS = NTSTATUS(1075708679i32 as _);
pub const STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET: NTSTATUS = NTSTATUS(-1071774931i32 as _);
pub const STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE: NTSTATUS = NTSTATUS(-1071774930i32 as _);
pub const STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET: NTSTATUS = NTSTATUS(-1071774932i32 as _);
pub const STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER: NTSTATUS = NTSTATUS(-1071774924i32 as _);
pub const STATUS_GRAPHICS_MONITOR_NOT_CONNECTED: NTSTATUS = NTSTATUS(-1071774920i32 as _);
pub const STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS: NTSTATUS = NTSTATUS(-1071774323i32 as _);
pub const STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774903i32 as _);
pub const STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER: NTSTATUS = NTSTATUS(-1071774672i32 as _);
pub const STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER: NTSTATUS = NTSTATUS(-1071775744i32 as _);
pub const STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER: NTSTATUS = NTSTATUS(-1071774664i32 as _);
pub const STATUS_GRAPHICS_NO_ACTIVE_VIDPN: NTSTATUS = NTSTATUS(-1071774922i32 as _);
pub const STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS: NTSTATUS = NTSTATUS(-1071774892i32 as _);
pub const STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET: NTSTATUS = NTSTATUS(-1071774925i32 as _);
pub const STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME: NTSTATUS = NTSTATUS(-1071774239i32 as _);
pub const STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT: NTSTATUS = NTSTATUS(-1071774911i32 as _);
pub const STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE: NTSTATUS = NTSTATUS(-1071774235i32 as _);
pub const STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET: NTSTATUS = NTSTATUS(1075708748i32 as _);
pub const STATUS_GRAPHICS_NO_PREFERRED_MODE: NTSTATUS = NTSTATUS(1075708702i32 as _);
pub const STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN: NTSTATUS = NTSTATUS(-1071774941i32 as _);
pub const STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY: NTSTATUS = NTSTATUS(-1071774950i32 as _);
pub const STATUS_GRAPHICS_NO_VIDEO_MEMORY: NTSTATUS = NTSTATUS(-1071775488i32 as _);
pub const STATUS_GRAPHICS_NO_VIDPNMGR: NTSTATUS = NTSTATUS(-1071774923i32 as _);
pub const STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED: NTSTATUS = NTSTATUS(-1071774240i32 as _);
pub const STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE: NTSTATUS = NTSTATUS(-1071774440i32 as _);
pub const STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1071774434i32 as _);
pub const STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET: NTSTATUS = NTSTATUS(-1071774442i32 as _);
pub const STATUS_GRAPHICS_OPM_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1071774453i32 as _);
pub const STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST: NTSTATUS = NTSTATUS(-1071774431i32 as _);
pub const STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS: NTSTATUS = NTSTATUS(-1071774461i32 as _);
pub const STATUS_GRAPHICS_OPM_INVALID_HANDLE: NTSTATUS = NTSTATUS(-1071774452i32 as _);
pub const STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST: NTSTATUS = NTSTATUS(-1071774435i32 as _);
pub const STATUS_GRAPHICS_OPM_INVALID_SRM: NTSTATUS = NTSTATUS(-1071774446i32 as _);
pub const STATUS_GRAPHICS_OPM_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774464i32 as _);
pub const STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST: NTSTATUS = NTSTATUS(-1071774459i32 as _);
pub const STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP: NTSTATUS = NTSTATUS(-1071774444i32 as _);
pub const STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA: NTSTATUS = NTSTATUS(-1071774443i32 as _);
pub const STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP: NTSTATUS = NTSTATUS(-1071774445i32 as _);
pub const STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS: NTSTATUS = NTSTATUS(-1071774436i32 as _);
pub const STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS: NTSTATUS = NTSTATUS(-1071774433i32 as _);
pub const STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS: NTSTATUS = NTSTATUS(-1071774438i32 as _);
pub const STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH: NTSTATUS = NTSTATUS(-1071774441i32 as _);
pub const STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774432i32 as _);
pub const STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED: NTSTATUS = NTSTATUS(-1071774449i32 as _);
pub const STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED: NTSTATUS = NTSTATUS(-1071774448i32 as _);
pub const STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL: NTSTATUS = NTSTATUS(-1071774234i32 as _);
pub const STATUS_GRAPHICS_PARTIAL_DATA_POPULATED: NTSTATUS = NTSTATUS(1075707914i32 as _);
pub const STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY: NTSTATUS = NTSTATUS(-1071774957i32 as _);
pub const STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED: NTSTATUS = NTSTATUS(1075708753i32 as _);
pub const STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774906i32 as _);
pub const STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY: NTSTATUS = NTSTATUS(-1071774937i32 as _);
pub const STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET: NTSTATUS = NTSTATUS(-1071774958i32 as _);
pub const STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY: NTSTATUS = NTSTATUS(1075708985i32 as _);
pub const STATUS_GRAPHICS_PRESENT_BUFFER_NOT_BOUND: NTSTATUS = NTSTATUS(-1071775728i32 as _);
pub const STATUS_GRAPHICS_PRESENT_DENIED: NTSTATUS = NTSTATUS(-1071775737i32 as _);
pub const STATUS_GRAPHICS_PRESENT_INVALID_WINDOW: NTSTATUS = NTSTATUS(-1071775729i32 as _);
pub const STATUS_GRAPHICS_PRESENT_MODE_CHANGED: NTSTATUS = NTSTATUS(-1071775739i32 as _);
pub const STATUS_GRAPHICS_PRESENT_OCCLUDED: NTSTATUS = NTSTATUS(-1071775738i32 as _);
pub const STATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLED: NTSTATUS = NTSTATUS(-1071775733i32 as _);
pub const STATUS_GRAPHICS_PRESENT_UNOCCLUDED: NTSTATUS = NTSTATUS(-1071775732i32 as _);
pub const STATUS_GRAPHICS_PVP_HFS_FAILED: NTSTATUS = NTSTATUS(-1071774447i32 as _);
pub const STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH: NTSTATUS = NTSTATUS(-1071774450i32 as _);
pub const STATUS_GRAPHICS_RESOURCES_NOT_RELATED: NTSTATUS = NTSTATUS(-1071774928i32 as _);
pub const STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS: NTSTATUS = NTSTATUS(-1071774232i32 as _);
pub const STATUS_GRAPHICS_SKIP_ALLOCATION_PREPARATION: NTSTATUS = NTSTATUS(1075708417i32 as _);
pub const STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET: NTSTATUS = NTSTATUS(-1071774953i32 as _);
pub const STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE: NTSTATUS = NTSTATUS(-1071774927i32 as _);
pub const STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY: NTSTATUS = NTSTATUS(-1071774919i32 as _);
pub const STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED: NTSTATUS = NTSTATUS(-1071774720i32 as _);
pub const STATUS_GRAPHICS_STALE_MODESET: NTSTATUS = NTSTATUS(-1071774944i32 as _);
pub const STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY: NTSTATUS = NTSTATUS(-1071774921i32 as _);
pub const STATUS_GRAPHICS_START_DEFERRED: NTSTATUS = NTSTATUS(1075708986i32 as _);
pub const STATUS_GRAPHICS_TARGET_ALREADY_IN_SET: NTSTATUS = NTSTATUS(-1071774952i32 as _);
pub const STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE: NTSTATUS = NTSTATUS(-1071774926i32 as _);
pub const STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY: NTSTATUS = NTSTATUS(-1071774912i32 as _);
pub const STATUS_GRAPHICS_TOO_MANY_REFERENCES: NTSTATUS = NTSTATUS(-1071775485i32 as _);
pub const STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1071774893i32 as _);
pub const STATUS_GRAPHICS_TRY_AGAIN_LATER: NTSTATUS = NTSTATUS(-1071775484i32 as _);
pub const STATUS_GRAPHICS_TRY_AGAIN_NOW: NTSTATUS = NTSTATUS(-1071775483i32 as _);
pub const STATUS_GRAPHICS_UAB_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774462i32 as _);
pub const STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1071774896i32 as _);
pub const STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS: NTSTATUS = NTSTATUS(1075708975i32 as _);
pub const STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE: NTSTATUS = NTSTATUS(-1071775481i32 as _);
pub const STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED: NTSTATUS = NTSTATUS(-1071775480i32 as _);
pub const STATUS_GRAPHICS_VAIL_STATE_CHANGED: NTSTATUS = NTSTATUS(-1071775727i32 as _);
pub const STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES: NTSTATUS = NTSTATUS(-1071774938i32 as _);
pub const STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774970i32 as _);
pub const STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE: NTSTATUS = NTSTATUS(-1071774910i32 as _);
pub const STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774974i32 as _);
pub const STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071774975i32 as _);
pub const STATUS_GRAPHICS_WINDOWDC_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1071775731i32 as _);
pub const STATUS_GRAPHICS_WINDOWLESS_PRESENT_DISABLED: NTSTATUS = NTSTATUS(-1071775730i32 as _);
pub const STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE: NTSTATUS = NTSTATUS(-1071775467i32 as _);
pub const STATUS_GROUP_EXISTS: NTSTATUS = NTSTATUS(-1073741723i32 as _);
pub const STATUS_GUARD_PAGE_VIOLATION: NTSTATUS = NTSTATUS(-2147483647i32 as _);
pub const STATUS_GUIDS_EXHAUSTED: NTSTATUS = NTSTATUS(-1073741693i32 as _);
pub const STATUS_GUID_SUBSTITUTION_MADE: NTSTATUS = NTSTATUS(-2147483636i32 as _);
pub const STATUS_HANDLES_CLOSED: NTSTATUS = NTSTATUS(-2147483638i32 as _);
pub const STATUS_HANDLE_NOT_CLOSABLE: NTSTATUS = NTSTATUS(-1073741259i32 as _);
pub const STATUS_HANDLE_NO_LONGER_VALID: NTSTATUS = NTSTATUS(-1072103384i32 as _);
pub const STATUS_HANDLE_REVOKED: NTSTATUS = NTSTATUS(-1073700858i32 as _);
pub const STATUS_HARDWARE_MEMORY_ERROR: NTSTATUS = NTSTATUS(-1073740023i32 as _);
pub const STATUS_HASH_NOT_PRESENT: NTSTATUS = NTSTATUS(-1073700607i32 as _);
pub const STATUS_HASH_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073700608i32 as _);
pub const STATUS_HAS_SYSTEM_CRITICAL_FILES: NTSTATUS = NTSTATUS(-1073740611i32 as _);
pub const STATUS_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1069285373i32 as _);
pub const STATUS_HDAUDIO_EMPTY_CONNECTION_LIST: NTSTATUS = NTSTATUS(-1069285374i32 as _);
pub const STATUS_HDAUDIO_NO_LOGICAL_DEVICES_CREATED: NTSTATUS = NTSTATUS(-1069285372i32 as _);
pub const STATUS_HDAUDIO_NULL_LINKED_LIST_ENTRY: NTSTATUS = NTSTATUS(-1069285371i32 as _);
pub const STATUS_HEAP_CORRUPTION: NTSTATUS = NTSTATUS(-1073740940i32 as _);
pub const STATUS_HEURISTIC_DAMAGE_POSSIBLE: NTSTATUS = NTSTATUS(1075380225i32 as _);
pub const STATUS_HIBERNATED: NTSTATUS = NTSTATUS(1073741866i32 as _);
pub const STATUS_HIBERNATION_FAILURE: NTSTATUS = NTSTATUS(-1073740783i32 as _);
pub const STATUS_HIVE_UNLOADED: NTSTATUS = NTSTATUS(-1073740763i32 as _);
pub const STATUS_HMAC_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073700863i32 as _);
pub const STATUS_HOPLIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1073700846i32 as _);
pub const STATUS_HOST_DOWN: NTSTATUS = NTSTATUS(-1073740976i32 as _);
pub const STATUS_HOST_UNREACHABLE: NTSTATUS = NTSTATUS(-1073741251i32 as _);
pub const STATUS_HUNG_DISPLAY_DRIVER_THREAD: NTSTATUS = NTSTATUS(-1073740779i32 as _);
pub const STATUS_HV_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1070268410i32 as _);
pub const STATUS_HV_ACKNOWLEDGED: NTSTATUS = NTSTATUS(-1070268394i32 as _);
pub const STATUS_HV_CALL_PENDING: NTSTATUS = NTSTATUS(-1070268295i32 as _);
pub const STATUS_HV_CPUID_FEATURE_VALIDATION_ERROR: NTSTATUS = NTSTATUS(-1070268356i32 as _);
pub const STATUS_HV_CPUID_XSAVE_FEATURE_VALIDATION_ERROR: NTSTATUS = NTSTATUS(-1070268355i32 as _);
pub const STATUS_HV_DEVICE_NOT_IN_DOMAIN: NTSTATUS = NTSTATUS(-1070268298i32 as _);
pub const STATUS_HV_EVENT_BUFFER_ALREADY_FREED: NTSTATUS = NTSTATUS(-1070268300i32 as _);
pub const STATUS_HV_FEATURE_UNAVAILABLE: NTSTATUS = NTSTATUS(-1070268386i32 as _);
pub const STATUS_HV_INACTIVE: NTSTATUS = NTSTATUS(-1070268388i32 as _);
pub const STATUS_HV_INSUFFICIENT_BUFFER: NTSTATUS = NTSTATUS(-1070268365i32 as _);
pub const STATUS_HV_INSUFFICIENT_BUFFERS: NTSTATUS = NTSTATUS(-1070268397i32 as _);
pub const STATUS_HV_INSUFFICIENT_CONTIGUOUS_MEMORY: NTSTATUS = NTSTATUS(-1070268299i32 as _);
pub const STATUS_HV_INSUFFICIENT_DEVICE_DOMAINS: NTSTATUS = NTSTATUS(-1070268360i32 as _);
pub const STATUS_HV_INSUFFICIENT_MEMORY: NTSTATUS = NTSTATUS(-1070268405i32 as _);
pub const STATUS_HV_INSUFFICIENT_ROOT_MEMORY: NTSTATUS = NTSTATUS(-1070268301i32 as _);
pub const STATUS_HV_INVALID_ALIGNMENT: NTSTATUS = NTSTATUS(-1070268412i32 as _);
pub const STATUS_HV_INVALID_CONNECTION_ID: NTSTATUS = NTSTATUS(-1070268398i32 as _);
pub const STATUS_HV_INVALID_CPU_GROUP_ID: NTSTATUS = NTSTATUS(-1070268305i32 as _);
pub const STATUS_HV_INVALID_CPU_GROUP_STATE: NTSTATUS = NTSTATUS(-1070268304i32 as _);
pub const STATUS_HV_INVALID_DEVICE_ID: NTSTATUS = NTSTATUS(-1070268329i32 as _);
pub const STATUS_HV_INVALID_DEVICE_STATE: NTSTATUS = NTSTATUS(-1070268328i32 as _);
pub const STATUS_HV_INVALID_HYPERCALL_CODE: NTSTATUS = NTSTATUS(-1070268414i32 as _);
pub const STATUS_HV_INVALID_HYPERCALL_INPUT: NTSTATUS = NTSTATUS(-1070268413i32 as _);
pub const STATUS_HV_INVALID_LP_INDEX: NTSTATUS = NTSTATUS(-1070268351i32 as _);
pub const STATUS_HV_INVALID_PARAMETER: NTSTATUS = NTSTATUS(-1070268411i32 as _);
pub const STATUS_HV_INVALID_PARTITION_ID: NTSTATUS = NTSTATUS(-1070268403i32 as _);
pub const STATUS_HV_INVALID_PARTITION_STATE: NTSTATUS = NTSTATUS(-1070268409i32 as _);
pub const STATUS_HV_INVALID_PORT_ID: NTSTATUS = NTSTATUS(-1070268399i32 as _);
pub const STATUS_HV_INVALID_PROXIMITY_DOMAIN_INFO: NTSTATUS = NTSTATUS(-1070268390i32 as _);
pub const STATUS_HV_INVALID_REGISTER_VALUE: NTSTATUS = NTSTATUS(-1070268336i32 as _);
pub const STATUS_HV_INVALID_SAVE_RESTORE_STATE: NTSTATUS = NTSTATUS(-1070268393i32 as _);
pub const STATUS_HV_INVALID_SYNIC_STATE: NTSTATUS = NTSTATUS(-1070268392i32 as _);
pub const STATUS_HV_INVALID_VP_INDEX: NTSTATUS = NTSTATUS(-1070268402i32 as _);
pub const STATUS_HV_INVALID_VP_STATE: NTSTATUS = NTSTATUS(-1070268395i32 as _);
pub const STATUS_HV_INVALID_VTL_STATE: NTSTATUS = NTSTATUS(-1070268335i32 as _);
pub const STATUS_HV_MSR_ACCESS_FAILED: NTSTATUS = NTSTATUS(-1070268288i32 as _);
pub const STATUS_HV_NESTED_VM_EXIT: NTSTATUS = NTSTATUS(-1070268297i32 as _);
pub const STATUS_HV_NOT_ACKNOWLEDGED: NTSTATUS = NTSTATUS(-1070268396i32 as _);
pub const STATUS_HV_NOT_ALLOWED_WITH_NESTED_VIRT_ACTIVE: NTSTATUS = NTSTATUS(-1070268302i32 as _);
pub const STATUS_HV_NOT_PRESENT: NTSTATUS = NTSTATUS(-1070264320i32 as _);
pub const STATUS_HV_NO_DATA: NTSTATUS = NTSTATUS(-1070268389i32 as _);
pub const STATUS_HV_NO_RESOURCES: NTSTATUS = NTSTATUS(-1070268387i32 as _);
pub const STATUS_HV_NX_NOT_DETECTED: NTSTATUS = NTSTATUS(-1070268331i32 as _);
pub const STATUS_HV_OBJECT_IN_USE: NTSTATUS = NTSTATUS(-1070268391i32 as _);
pub const STATUS_HV_OPERATION_DENIED: NTSTATUS = NTSTATUS(-1070268408i32 as _);
pub const STATUS_HV_OPERATION_FAILED: NTSTATUS = NTSTATUS(-1070268303i32 as _);
pub const STATUS_HV_PAGE_REQUEST_INVALID: NTSTATUS = NTSTATUS(-1070268320i32 as _);
pub const STATUS_HV_PARTITION_TOO_DEEP: NTSTATUS = NTSTATUS(-1070268404i32 as _);
pub const STATUS_HV_PENDING_PAGE_REQUESTS: NTSTATUS = NTSTATUS(3473497i32 as _);
pub const STATUS_HV_PROCESSOR_STARTUP_TIMEOUT: NTSTATUS = NTSTATUS(-1070268354i32 as _);
pub const STATUS_HV_PROPERTY_VALUE_OUT_OF_RANGE: NTSTATUS = NTSTATUS(-1070268406i32 as _);
pub const STATUS_HV_SMX_ENABLED: NTSTATUS = NTSTATUS(-1070268353i32 as _);
pub const STATUS_HV_UNKNOWN_PROPERTY: NTSTATUS = NTSTATUS(-1070268407i32 as _);
pub const STATUS_ILLEGAL_CHARACTER: NTSTATUS = NTSTATUS(-1073741471i32 as _);
pub const STATUS_ILLEGAL_DLL_RELOCATION: NTSTATUS = NTSTATUS(-1073741207i32 as _);
pub const STATUS_ILLEGAL_ELEMENT_ADDRESS: NTSTATUS = NTSTATUS(-1073741179i32 as _);
pub const STATUS_ILLEGAL_FLOAT_CONTEXT: NTSTATUS = NTSTATUS(-1073741494i32 as _);
pub const STATUS_ILLEGAL_FUNCTION: NTSTATUS = NTSTATUS(-1073741649i32 as _);
pub const STATUS_ILLEGAL_INSTRUCTION: NTSTATUS = NTSTATUS(-1073741795i32 as _);
pub const STATUS_ILL_FORMED_PASSWORD: NTSTATUS = NTSTATUS(-1073741717i32 as _);
pub const STATUS_ILL_FORMED_SERVICE_ENTRY: NTSTATUS = NTSTATUS(-1073741472i32 as _);
pub const STATUS_IMAGE_ALREADY_LOADED: NTSTATUS = NTSTATUS(-1073741554i32 as _);
pub const STATUS_IMAGE_ALREADY_LOADED_AS_DLL: NTSTATUS = NTSTATUS(-1073741411i32 as _);
pub const STATUS_IMAGE_AT_DIFFERENT_BASE: NTSTATUS = NTSTATUS(1073741878i32 as _);
pub const STATUS_IMAGE_CERT_EXPIRED: NTSTATUS = NTSTATUS(-1073740283i32 as _);
pub const STATUS_IMAGE_CERT_REVOKED: NTSTATUS = NTSTATUS(-1073740285i32 as _);
pub const STATUS_IMAGE_CHECKSUM_MISMATCH: NTSTATUS = NTSTATUS(-1073741279i32 as _);
pub const STATUS_IMAGE_LOADED_AS_PATCH_IMAGE: NTSTATUS = NTSTATUS(-1073740608i32 as _);
pub const STATUS_IMAGE_MACHINE_TYPE_MISMATCH: NTSTATUS = NTSTATUS(1073741838i32 as _);
pub const STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE: NTSTATUS = NTSTATUS(1073741859i32 as _);
pub const STATUS_IMAGE_MP_UP_MISMATCH: NTSTATUS = NTSTATUS(-1073741239i32 as _);
pub const STATUS_IMAGE_NOT_AT_BASE: NTSTATUS = NTSTATUS(1073741827i32 as _);
pub const STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT: NTSTATUS = NTSTATUS(-1073741405i32 as _);
pub const STATUS_IMPLEMENTATION_LIMIT: NTSTATUS = NTSTATUS(-1073740757i32 as _);
pub const STATUS_INCOMPATIBLE_DRIVER_BLOCKED: NTSTATUS = NTSTATUS(-1073740764i32 as _);
pub const STATUS_INCOMPATIBLE_FILE_MAP: NTSTATUS = NTSTATUS(-1073741747i32 as _);
pub const STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING: NTSTATUS = NTSTATUS(-1073741410i32 as _);
pub const STATUS_INCORRECT_ACCOUNT_TYPE: NTSTATUS = NTSTATUS(-1073700727i32 as _);
pub const STATUS_INDEX_OUT_OF_BOUNDS: NTSTATUS = NTSTATUS(-1073740591i32 as _);
pub const STATUS_INDOUBT_TRANSACTIONS_EXIST: NTSTATUS = NTSTATUS(-1072103366i32 as _);
pub const STATUS_INFO_LENGTH_MISMATCH: NTSTATUS = NTSTATUS(-1073741820i32 as _);
pub const STATUS_INSTANCE_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1073741653i32 as _);
pub const STATUS_INSTRUCTION_MISALIGNMENT: NTSTATUS = NTSTATUS(-1073741654i32 as _);
pub const STATUS_INSUFFICIENT_LOGON_INFO: NTSTATUS = NTSTATUS(-1073741232i32 as _);
pub const STATUS_INSUFFICIENT_NVRAM_RESOURCES: NTSTATUS = NTSTATUS(-1073740716i32 as _);
pub const STATUS_INSUFFICIENT_POWER: NTSTATUS = NTSTATUS(-1073741090i32 as _);
pub const STATUS_INSUFFICIENT_RESOURCES: NTSTATUS = NTSTATUS(-1073741670i32 as _);
pub const STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE: NTSTATUS = NTSTATUS(-1073740778i32 as _);
pub const STATUS_INSUFFICIENT_VIRTUAL_ADDR_RESOURCES: NTSTATUS = NTSTATUS(-1073740606i32 as _);
pub const STATUS_INSUFF_SERVER_RESOURCES: NTSTATUS = NTSTATUS(-1073741307i32 as _);
pub const STATUS_INTEGER_DIVIDE_BY_ZERO: NTSTATUS = NTSTATUS(-1073741676i32 as _);
pub const STATUS_INTEGER_OVERFLOW: NTSTATUS = NTSTATUS(-1073741675i32 as _);
pub const STATUS_INTERMIXED_KERNEL_EA_OPERATION: NTSTATUS = NTSTATUS(-1073740687i32 as _);
pub const STATUS_INTERNAL_DB_CORRUPTION: NTSTATUS = NTSTATUS(-1073741596i32 as _);
pub const STATUS_INTERNAL_DB_ERROR: NTSTATUS = NTSTATUS(-1073741480i32 as _);
pub const STATUS_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1073741595i32 as _);
pub const STATUS_INTERRUPTED: NTSTATUS = NTSTATUS(-1073740523i32 as _);
pub const STATUS_INTERRUPT_STILL_CONNECTED: NTSTATUS = NTSTATUS(296i32 as _);
pub const STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED: NTSTATUS = NTSTATUS(295i32 as _);
pub const STATUS_INVALID_ACCOUNT_NAME: NTSTATUS = NTSTATUS(-1073741726i32 as _);
pub const STATUS_INVALID_ACE_CONDITION: NTSTATUS = NTSTATUS(-1073741406i32 as _);
pub const STATUS_INVALID_ACL: NTSTATUS = NTSTATUS(-1073741705i32 as _);
pub const STATUS_INVALID_ADDRESS: NTSTATUS = NTSTATUS(-1073741503i32 as _);
pub const STATUS_INVALID_ADDRESS_COMPONENT: NTSTATUS = NTSTATUS(-1073741305i32 as _);
pub const STATUS_INVALID_ADDRESS_WILDCARD: NTSTATUS = NTSTATUS(-1073741304i32 as _);
pub const STATUS_INVALID_BLOCK_LENGTH: NTSTATUS = NTSTATUS(-1073741453i32 as _);
pub const STATUS_INVALID_BUFFER_SIZE: NTSTATUS = NTSTATUS(-1073741306i32 as _);
pub const STATUS_INVALID_CAP: NTSTATUS = NTSTATUS(-1073740539i32 as _);
pub const STATUS_INVALID_CID: NTSTATUS = NTSTATUS(-1073741813i32 as _);
pub const STATUS_INVALID_COMPUTER_NAME: NTSTATUS = NTSTATUS(-1073741534i32 as _);
pub const STATUS_INVALID_CONNECTION: NTSTATUS = NTSTATUS(-1073741504i32 as _);
pub const STATUS_INVALID_CRUNTIME_PARAMETER: NTSTATUS = NTSTATUS(-1073740777i32 as _);
pub const STATUS_INVALID_DEVICE_OBJECT_PARAMETER: NTSTATUS = NTSTATUS(-1073740951i32 as _);
pub const STATUS_INVALID_DEVICE_REQUEST: NTSTATUS = NTSTATUS(-1073741808i32 as _);
pub const STATUS_INVALID_DEVICE_STATE: NTSTATUS = NTSTATUS(-1073741436i32 as _);
pub const STATUS_INVALID_DISPOSITION: NTSTATUS = NTSTATUS(-1073741786i32 as _);
pub const STATUS_INVALID_DOMAIN_ROLE: NTSTATUS = NTSTATUS(-1073741602i32 as _);
pub const STATUS_INVALID_DOMAIN_STATE: NTSTATUS = NTSTATUS(-1073741603i32 as _);
pub const STATUS_INVALID_EA_FLAG: NTSTATUS = NTSTATUS(-2147483627i32 as _);
pub const STATUS_INVALID_EA_NAME: NTSTATUS = NTSTATUS(-2147483629i32 as _);
pub const STATUS_INVALID_EXCEPTION_HANDLER: NTSTATUS = NTSTATUS(-1073741403i32 as _);
pub const STATUS_INVALID_FIELD_IN_PARAMETER_LIST: NTSTATUS = NTSTATUS(-1073740683i32 as _);
pub const STATUS_INVALID_FILE_FOR_SECTION: NTSTATUS = NTSTATUS(-1073741792i32 as _);
pub const STATUS_INVALID_GROUP_ATTRIBUTES: NTSTATUS = NTSTATUS(-1073741660i32 as _);
pub const STATUS_INVALID_HANDLE: NTSTATUS = NTSTATUS(-1073741816i32 as _);
pub const STATUS_INVALID_HW_PROFILE: NTSTATUS = NTSTATUS(-1073741216i32 as _);
pub const STATUS_INVALID_IDN_NORMALIZATION: NTSTATUS = NTSTATUS(-1073740010i32 as _);
pub const STATUS_INVALID_ID_AUTHORITY: NTSTATUS = NTSTATUS(-1073741692i32 as _);
pub const STATUS_INVALID_IMAGE_FORMAT: NTSTATUS = NTSTATUS(-1073741701i32 as _);
pub const STATUS_INVALID_IMAGE_HASH: NTSTATUS = NTSTATUS(-1073740760i32 as _);
pub const STATUS_INVALID_IMAGE_LE_FORMAT: NTSTATUS = NTSTATUS(-1073741522i32 as _);
pub const STATUS_INVALID_IMAGE_NE_FORMAT: NTSTATUS = NTSTATUS(-1073741541i32 as _);
pub const STATUS_INVALID_IMAGE_NOT_MZ: NTSTATUS = NTSTATUS(-1073741521i32 as _);
pub const STATUS_INVALID_IMAGE_PROTECT: NTSTATUS = NTSTATUS(-1073741520i32 as _);
pub const STATUS_INVALID_IMAGE_WIN_16: NTSTATUS = NTSTATUS(-1073741519i32 as _);
pub const STATUS_INVALID_IMAGE_WIN_32: NTSTATUS = NTSTATUS(-1073740967i32 as _);
pub const STATUS_INVALID_IMAGE_WIN_64: NTSTATUS = NTSTATUS(-1073740966i32 as _);
pub const STATUS_INVALID_IMPORT_OF_NON_DLL: NTSTATUS = NTSTATUS(-1073740945i32 as _);
pub const STATUS_INVALID_INFO_CLASS: NTSTATUS = NTSTATUS(-1073741821i32 as _);
pub const STATUS_INVALID_INITIATOR_TARGET_PATH: NTSTATUS = NTSTATUS(-1073740681i32 as _);
pub const STATUS_INVALID_KERNEL_INFO_VERSION: NTSTATUS = NTSTATUS(-1073700860i32 as _);
pub const STATUS_INVALID_LABEL: NTSTATUS = NTSTATUS(-1073740730i32 as _);
pub const STATUS_INVALID_LDT_DESCRIPTOR: NTSTATUS = NTSTATUS(-1073741542i32 as _);
pub const STATUS_INVALID_LDT_OFFSET: NTSTATUS = NTSTATUS(-1073741543i32 as _);
pub const STATUS_INVALID_LDT_SIZE: NTSTATUS = NTSTATUS(-1073741544i32 as _);
pub const STATUS_INVALID_LEVEL: NTSTATUS = NTSTATUS(-1073741496i32 as _);
pub const STATUS_INVALID_LOCK_RANGE: NTSTATUS = NTSTATUS(-1073741407i32 as _);
pub const STATUS_INVALID_LOCK_SEQUENCE: NTSTATUS = NTSTATUS(-1073741794i32 as _);
pub const STATUS_INVALID_LOGON_HOURS: NTSTATUS = NTSTATUS(-1073741713i32 as _);
pub const STATUS_INVALID_LOGON_TYPE: NTSTATUS = NTSTATUS(-1073741557i32 as _);
pub const STATUS_INVALID_MEMBER: NTSTATUS = NTSTATUS(-1073741445i32 as _);
pub const STATUS_INVALID_MESSAGE: NTSTATUS = NTSTATUS(-1073740030i32 as _);
pub const STATUS_INVALID_NETWORK_RESPONSE: NTSTATUS = NTSTATUS(-1073741629i32 as _);
pub const STATUS_INVALID_OFFSET_ALIGNMENT: NTSTATUS = NTSTATUS(-1073740684i32 as _);
pub const STATUS_INVALID_OPLOCK_PROTOCOL: NTSTATUS = NTSTATUS(-1073741597i32 as _);
pub const STATUS_INVALID_OWNER: NTSTATUS = NTSTATUS(-1073741734i32 as _);
pub const STATUS_INVALID_PACKAGE_SID_LENGTH: NTSTATUS = NTSTATUS(-1073700350i32 as _);
pub const STATUS_INVALID_PAGE_PROTECTION: NTSTATUS = NTSTATUS(-1073741755i32 as _);
pub const STATUS_INVALID_PARAMETER: NTSTATUS = NTSTATUS(-1073741811i32 as _);
pub const STATUS_INVALID_PARAMETER_1: NTSTATUS = NTSTATUS(-1073741585i32 as _);
pub const STATUS_INVALID_PARAMETER_10: NTSTATUS = NTSTATUS(-1073741576i32 as _);
pub const STATUS_INVALID_PARAMETER_11: NTSTATUS = NTSTATUS(-1073741575i32 as _);
pub const STATUS_INVALID_PARAMETER_12: NTSTATUS = NTSTATUS(-1073741574i32 as _);
pub const STATUS_INVALID_PARAMETER_2: NTSTATUS = NTSTATUS(-1073741584i32 as _);
pub const STATUS_INVALID_PARAMETER_3: NTSTATUS = NTSTATUS(-1073741583i32 as _);
pub const STATUS_INVALID_PARAMETER_4: NTSTATUS = NTSTATUS(-1073741582i32 as _);
pub const STATUS_INVALID_PARAMETER_5: NTSTATUS = NTSTATUS(-1073741581i32 as _);
pub const STATUS_INVALID_PARAMETER_6: NTSTATUS = NTSTATUS(-1073741580i32 as _);
pub const STATUS_INVALID_PARAMETER_7: NTSTATUS = NTSTATUS(-1073741579i32 as _);
pub const STATUS_INVALID_PARAMETER_8: NTSTATUS = NTSTATUS(-1073741578i32 as _);
pub const STATUS_INVALID_PARAMETER_9: NTSTATUS = NTSTATUS(-1073741577i32 as _);
pub const STATUS_INVALID_PARAMETER_MIX: NTSTATUS = NTSTATUS(-1073741776i32 as _);
pub const STATUS_INVALID_PEP_INFO_VERSION: NTSTATUS = NTSTATUS(-1073700859i32 as _);
pub const STATUS_INVALID_PIPE_STATE: NTSTATUS = NTSTATUS(-1073741651i32 as _);
pub const STATUS_INVALID_PLUGPLAY_DEVICE_PATH: NTSTATUS = NTSTATUS(-1073741215i32 as _);
pub const STATUS_INVALID_PORT_ATTRIBUTES: NTSTATUS = NTSTATUS(-1073741778i32 as _);
pub const STATUS_INVALID_PORT_HANDLE: NTSTATUS = NTSTATUS(-1073741758i32 as _);
pub const STATUS_INVALID_PRIMARY_GROUP: NTSTATUS = NTSTATUS(-1073741733i32 as _);
pub const STATUS_INVALID_QUOTA_LOWER: NTSTATUS = NTSTATUS(-1073741775i32 as _);
pub const STATUS_INVALID_READ_MODE: NTSTATUS = NTSTATUS(-1073741644i32 as _);
pub const STATUS_INVALID_RUNLEVEL_SETTING: NTSTATUS = NTSTATUS(-1073700542i32 as _);
pub const STATUS_INVALID_SECURITY_DESCR: NTSTATUS = NTSTATUS(-1073741703i32 as _);
pub const STATUS_INVALID_SERVER_STATE: NTSTATUS = NTSTATUS(-1073741604i32 as _);
pub const STATUS_INVALID_SESSION: NTSTATUS = NTSTATUS(-1073740715i32 as _);
pub const STATUS_INVALID_SID: NTSTATUS = NTSTATUS(-1073741704i32 as _);
pub const STATUS_INVALID_SIGNATURE: NTSTATUS = NTSTATUS(-1073700864i32 as _);
pub const STATUS_INVALID_STATE_TRANSITION: NTSTATUS = NTSTATUS(-1073700861i32 as _);
pub const STATUS_INVALID_SUB_AUTHORITY: NTSTATUS = NTSTATUS(-1073741706i32 as _);
pub const STATUS_INVALID_SYSTEM_SERVICE: NTSTATUS = NTSTATUS(-1073741796i32 as _);
pub const STATUS_INVALID_TASK_INDEX: NTSTATUS = NTSTATUS(-1073740543i32 as _);
pub const STATUS_INVALID_TASK_NAME: NTSTATUS = NTSTATUS(-1073740544i32 as _);
pub const STATUS_INVALID_THREAD: NTSTATUS = NTSTATUS(-1073740004i32 as _);
pub const STATUS_INVALID_TOKEN: NTSTATUS = NTSTATUS(-1073740699i32 as _);
pub const STATUS_INVALID_TRANSACTION: NTSTATUS = NTSTATUS(-1072103422i32 as _);
pub const STATUS_INVALID_UNWIND_TARGET: NTSTATUS = NTSTATUS(-1073741783i32 as _);
pub const STATUS_INVALID_USER_BUFFER: NTSTATUS = NTSTATUS(-1073741592i32 as _);
pub const STATUS_INVALID_USER_PRINCIPAL_NAME: NTSTATUS = NTSTATUS(-1073740772i32 as _);
pub const STATUS_INVALID_VARIANT: NTSTATUS = NTSTATUS(-1073741262i32 as _);
pub const STATUS_INVALID_VIEW_SIZE: NTSTATUS = NTSTATUS(-1073741793i32 as _);
pub const STATUS_INVALID_VOLUME_LABEL: NTSTATUS = NTSTATUS(-1073741690i32 as _);
pub const STATUS_INVALID_WEIGHT: NTSTATUS = NTSTATUS(-1073740712i32 as _);
pub const STATUS_INVALID_WORKSTATION: NTSTATUS = NTSTATUS(-1073741712i32 as _);
pub const STATUS_IN_PAGE_ERROR: NTSTATUS = NTSTATUS(-1073741818i32 as _);
pub const STATUS_IORING_COMPLETION_QUEUE_TOO_BIG: NTSTATUS = NTSTATUS(-1069154299i32 as _);
pub const STATUS_IORING_CORRUPT: NTSTATUS = NTSTATUS(-1069154297i32 as _);
pub const STATUS_IORING_REQUIRED_FLAG_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1069154303i32 as _);
pub const STATUS_IORING_SUBMISSION_QUEUE_FULL: NTSTATUS = NTSTATUS(-1069154302i32 as _);
pub const STATUS_IORING_SUBMISSION_QUEUE_TOO_BIG: NTSTATUS = NTSTATUS(-1069154300i32 as _);
pub const STATUS_IORING_SUBMIT_IN_PROGRESS: NTSTATUS = NTSTATUS(-1069154298i32 as _);
pub const STATUS_IORING_VERSION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1069154301i32 as _);
pub const STATUS_IO_DEVICE_ERROR: NTSTATUS = NTSTATUS(-1073741435i32 as _);
pub const STATUS_IO_DEVICE_INVALID_DATA: NTSTATUS = NTSTATUS(-1073741392i32 as _);
pub const STATUS_IO_OPERATION_TIMEOUT: NTSTATUS = NTSTATUS(-1073740675i32 as _);
pub const STATUS_IO_PREEMPTED: NTSTATUS = NTSTATUS(-1068433407i32 as _);
pub const STATUS_IO_PRIVILEGE_FAILED: NTSTATUS = NTSTATUS(-1073741513i32 as _);
pub const STATUS_IO_REISSUE_AS_CACHED: NTSTATUS = NTSTATUS(-1073479623i32 as _);
pub const STATUS_IO_REPARSE_DATA_INVALID: NTSTATUS = NTSTATUS(-1073741192i32 as _);
pub const STATUS_IO_REPARSE_TAG_INVALID: NTSTATUS = NTSTATUS(-1073741194i32 as _);
pub const STATUS_IO_REPARSE_TAG_MISMATCH: NTSTATUS = NTSTATUS(-1073741193i32 as _);
pub const STATUS_IO_REPARSE_TAG_NOT_HANDLED: NTSTATUS = NTSTATUS(-1073741191i32 as _);
pub const STATUS_IO_TIMEOUT: NTSTATUS = NTSTATUS(-1073741643i32 as _);
pub const STATUS_IO_UNALIGNED_WRITE: NTSTATUS = NTSTATUS(-1073741391i32 as _);
pub const STATUS_IPSEC_AUTH_FIREWALL_DROP: NTSTATUS = NTSTATUS(-1070202872i32 as _);
pub const STATUS_IPSEC_BAD_SPI: NTSTATUS = NTSTATUS(-1070202879i32 as _);
pub const STATUS_IPSEC_CLEAR_TEXT_DROP: NTSTATUS = NTSTATUS(-1070202873i32 as _);
pub const STATUS_IPSEC_DOSP_BLOCK: NTSTATUS = NTSTATUS(-1070170112i32 as _);
pub const STATUS_IPSEC_DOSP_INVALID_PACKET: NTSTATUS = NTSTATUS(-1070170110i32 as _);
pub const STATUS_IPSEC_DOSP_KEYMOD_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1070170107i32 as _);
pub const STATUS_IPSEC_DOSP_MAX_ENTRIES: NTSTATUS = NTSTATUS(-1070170108i32 as _);
pub const STATUS_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES: NTSTATUS = NTSTATUS(-1070170106i32 as _);
pub const STATUS_IPSEC_DOSP_RECEIVED_MULTICAST: NTSTATUS = NTSTATUS(-1070170111i32 as _);
pub const STATUS_IPSEC_DOSP_STATE_LOOKUP_FAILED: NTSTATUS = NTSTATUS(-1070170109i32 as _);
pub const STATUS_IPSEC_INTEGRITY_CHECK_FAILED: NTSTATUS = NTSTATUS(-1070202874i32 as _);
pub const STATUS_IPSEC_INVALID_PACKET: NTSTATUS = NTSTATUS(-1070202875i32 as _);
pub const STATUS_IPSEC_QUEUE_OVERFLOW: NTSTATUS = NTSTATUS(-1073700848i32 as _);
pub const STATUS_IPSEC_REPLAY_CHECK_FAILED: NTSTATUS = NTSTATUS(-1070202876i32 as _);
pub const STATUS_IPSEC_SA_LIFETIME_EXPIRED: NTSTATUS = NTSTATUS(-1070202878i32 as _);
pub const STATUS_IPSEC_THROTTLE_DROP: NTSTATUS = NTSTATUS(-1070202871i32 as _);
pub const STATUS_IPSEC_WRONG_SA: NTSTATUS = NTSTATUS(-1070202877i32 as _);
pub const STATUS_IP_ADDRESS_CONFLICT1: NTSTATUS = NTSTATUS(-1073741228i32 as _);
pub const STATUS_IP_ADDRESS_CONFLICT2: NTSTATUS = NTSTATUS(-1073741227i32 as _);
pub const STATUS_ISSUING_CA_UNTRUSTED: NTSTATUS = NTSTATUS(-1073740918i32 as _);
pub const STATUS_ISSUING_CA_UNTRUSTED_KDC: NTSTATUS = NTSTATUS(-1073740787i32 as _);
pub const STATUS_JOB_NOT_EMPTY: NTSTATUS = NTSTATUS(-1073740529i32 as _);
pub const STATUS_JOB_NO_CONTAINER: NTSTATUS = NTSTATUS(-1073740535i32 as _);
pub const STATUS_JOURNAL_DELETE_IN_PROGRESS: NTSTATUS = NTSTATUS(-1073741129i32 as _);
pub const STATUS_JOURNAL_ENTRY_DELETED: NTSTATUS = NTSTATUS(-1073741105i32 as _);
pub const STATUS_JOURNAL_NOT_ACTIVE: NTSTATUS = NTSTATUS(-1073741128i32 as _);
pub const STATUS_KDC_CERT_EXPIRED: NTSTATUS = NTSTATUS(-1073740786i32 as _);
pub const STATUS_KDC_CERT_REVOKED: NTSTATUS = NTSTATUS(-1073740785i32 as _);
pub const STATUS_KDC_INVALID_REQUEST: NTSTATUS = NTSTATUS(-1073741061i32 as _);
pub const STATUS_KDC_UNABLE_TO_REFER: NTSTATUS = NTSTATUS(-1073741060i32 as _);
pub const STATUS_KDC_UNKNOWN_ETYPE: NTSTATUS = NTSTATUS(-1073741059i32 as _);
pub const STATUS_KERNEL_APC: NTSTATUS = NTSTATUS(256i32 as _);
pub const STATUS_KERNEL_EXECUTABLE_MEMORY_WRITE: NTSTATUS = NTSTATUS(-1073739996i32 as _);
pub const STATUS_KEY_DELETED: NTSTATUS = NTSTATUS(-1073741444i32 as _);
pub const STATUS_KEY_HAS_CHILDREN: NTSTATUS = NTSTATUS(-1073741440i32 as _);
pub const STATUS_LAST_ADMIN: NTSTATUS = NTSTATUS(-1073741719i32 as _);
pub const STATUS_LICENSE_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1073741223i32 as _);
pub const STATUS_LICENSE_VIOLATION: NTSTATUS = NTSTATUS(-1073741206i32 as _);
pub const STATUS_LINK_FAILED: NTSTATUS = NTSTATUS(-1073741506i32 as _);
pub const STATUS_LINK_TIMEOUT: NTSTATUS = NTSTATUS(-1073741505i32 as _);
pub const STATUS_LM_CROSS_ENCRYPTION_REQUIRED: NTSTATUS = NTSTATUS(-1073741441i32 as _);
pub const STATUS_LOCAL_DISCONNECT: NTSTATUS = NTSTATUS(-1073741509i32 as _);
pub const STATUS_LOCAL_USER_SESSION_KEY: NTSTATUS = NTSTATUS(1073741830i32 as _);
pub const STATUS_LOCK_NOT_GRANTED: NTSTATUS = NTSTATUS(-1073741739i32 as _);
pub const STATUS_LOGIN_TIME_RESTRICTION: NTSTATUS = NTSTATUS(-1073741241i32 as _);
pub const STATUS_LOGIN_WKSTA_RESTRICTION: NTSTATUS = NTSTATUS(-1073741240i32 as _);
pub const STATUS_LOGON_NOT_GRANTED: NTSTATUS = NTSTATUS(-1073741483i32 as _);
pub const STATUS_LOGON_SERVER_CONFLICT: NTSTATUS = NTSTATUS(-1073741518i32 as _);
pub const STATUS_LOGON_SESSION_COLLISION: NTSTATUS = NTSTATUS(-1073741563i32 as _);
pub const STATUS_LOGON_SESSION_EXISTS: NTSTATUS = NTSTATUS(-1073741586i32 as _);
pub const STATUS_LOG_APPENDED_FLUSH_FAILED: NTSTATUS = NTSTATUS(-1072037841i32 as _);
pub const STATUS_LOG_ARCHIVE_IN_PROGRESS: NTSTATUS = NTSTATUS(-1072037855i32 as _);
pub const STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS: NTSTATUS = NTSTATUS(-1072037856i32 as _);
pub const STATUS_LOG_BLOCKS_EXHAUSTED: NTSTATUS = NTSTATUS(-1072037882i32 as _);
pub const STATUS_LOG_BLOCK_INCOMPLETE: NTSTATUS = NTSTATUS(-1072037884i32 as _);
pub const STATUS_LOG_BLOCK_INVALID: NTSTATUS = NTSTATUS(-1072037878i32 as _);
pub const STATUS_LOG_BLOCK_VERSION: NTSTATUS = NTSTATUS(-1072037879i32 as _);
pub const STATUS_LOG_CANT_DELETE: NTSTATUS = NTSTATUS(-1072037871i32 as _);
pub const STATUS_LOG_CLIENT_ALREADY_REGISTERED: NTSTATUS = NTSTATUS(-1072037852i32 as _);
pub const STATUS_LOG_CLIENT_NOT_REGISTERED: NTSTATUS = NTSTATUS(-1072037851i32 as _);
pub const STATUS_LOG_CONTAINER_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1072037870i32 as _);
pub const STATUS_LOG_CONTAINER_OPEN_FAILED: NTSTATUS = NTSTATUS(-1072037847i32 as _);
pub const STATUS_LOG_CONTAINER_READ_FAILED: NTSTATUS = NTSTATUS(-1072037849i32 as _);
pub const STATUS_LOG_CONTAINER_STATE_INVALID: NTSTATUS = NTSTATUS(-1072037846i32 as _);
pub const STATUS_LOG_CONTAINER_WRITE_FAILED: NTSTATUS = NTSTATUS(-1072037848i32 as _);
pub const STATUS_LOG_CORRUPTION_DETECTED: NTSTATUS = NTSTATUS(-1072103376i32 as _);
pub const STATUS_LOG_DEDICATED: NTSTATUS = NTSTATUS(-1072037857i32 as _);
pub const STATUS_LOG_EPHEMERAL: NTSTATUS = NTSTATUS(-1072037854i32 as _);
pub const STATUS_LOG_FILE_FULL: NTSTATUS = NTSTATUS(-1073741432i32 as _);
pub const STATUS_LOG_FULL: NTSTATUS = NTSTATUS(-1072037859i32 as _);
pub const STATUS_LOG_FULL_HANDLER_IN_PROGRESS: NTSTATUS = NTSTATUS(-1072037850i32 as _);
pub const STATUS_LOG_GROWTH_FAILED: NTSTATUS = NTSTATUS(-1072103399i32 as _);
pub const STATUS_LOG_HARD_ERROR: NTSTATUS = NTSTATUS(1073741850i32 as _);
pub const STATUS_LOG_INCONSISTENT_SECURITY: NTSTATUS = NTSTATUS(-1072037842i32 as _);
pub const STATUS_LOG_INVALID_RANGE: NTSTATUS = NTSTATUS(-1072037883i32 as _);
pub const STATUS_LOG_METADATA_CORRUPT: NTSTATUS = NTSTATUS(-1072037875i32 as _);
pub const STATUS_LOG_METADATA_FLUSH_FAILED: NTSTATUS = NTSTATUS(-1072037843i32 as _);
pub const STATUS_LOG_METADATA_INCONSISTENT: NTSTATUS = NTSTATUS(-1072037873i32 as _);
pub const STATUS_LOG_METADATA_INVALID: NTSTATUS = NTSTATUS(-1072037874i32 as _);
pub const STATUS_LOG_MULTIPLEXED: NTSTATUS = NTSTATUS(-1072037858i32 as _);
pub const STATUS_LOG_NOT_ENOUGH_CONTAINERS: NTSTATUS = NTSTATUS(-1072037853i32 as _);
pub const STATUS_LOG_NO_RESTART: NTSTATUS = NTSTATUS(1075445772i32 as _);
pub const STATUS_LOG_PINNED: NTSTATUS = NTSTATUS(-1072037844i32 as _);
pub const STATUS_LOG_PINNED_ARCHIVE_TAIL: NTSTATUS = NTSTATUS(-1072037864i32 as _);
pub const STATUS_LOG_PINNED_RESERVATION: NTSTATUS = NTSTATUS(-1072037840i32 as _);
pub const STATUS_LOG_POLICY_ALREADY_INSTALLED: NTSTATUS = NTSTATUS(-1072037868i32 as _);
pub const STATUS_LOG_POLICY_CONFLICT: NTSTATUS = NTSTATUS(-1072037865i32 as _);
pub const STATUS_LOG_POLICY_INVALID: NTSTATUS = NTSTATUS(-1072037866i32 as _);
pub const STATUS_LOG_POLICY_NOT_INSTALLED: NTSTATUS = NTSTATUS(-1072037867i32 as _);
pub const STATUS_LOG_READ_CONTEXT_INVALID: NTSTATUS = NTSTATUS(-1072037881i32 as _);
pub const STATUS_LOG_READ_MODE_INVALID: NTSTATUS = NTSTATUS(-1072037877i32 as _);
pub const STATUS_LOG_RECORDS_RESERVED_INVALID: NTSTATUS = NTSTATUS(-1072037862i32 as _);
pub const STATUS_LOG_RECORD_NONEXISTENT: NTSTATUS = NTSTATUS(-1072037863i32 as _);
pub const STATUS_LOG_RESERVATION_INVALID: NTSTATUS = NTSTATUS(-1072037872i32 as _);
pub const STATUS_LOG_RESIZE_INVALID_SIZE: NTSTATUS = NTSTATUS(-1072103413i32 as _);
pub const STATUS_LOG_RESTART_INVALID: NTSTATUS = NTSTATUS(-1072037880i32 as _);
pub const STATUS_LOG_SECTOR_INVALID: NTSTATUS = NTSTATUS(-1072037887i32 as _);
pub const STATUS_LOG_SECTOR_PARITY_INVALID: NTSTATUS = NTSTATUS(-1072037886i32 as _);
pub const STATUS_LOG_SECTOR_REMAPPED: NTSTATUS = NTSTATUS(-1072037885i32 as _);
pub const STATUS_LOG_SPACE_RESERVED_INVALID: NTSTATUS = NTSTATUS(-1072037861i32 as _);
pub const STATUS_LOG_START_OF_LOG: NTSTATUS = NTSTATUS(-1072037869i32 as _);
pub const STATUS_LOG_STATE_INVALID: NTSTATUS = NTSTATUS(-1072037845i32 as _);
pub const STATUS_LOG_TAIL_INVALID: NTSTATUS = NTSTATUS(-1072037860i32 as _);
pub const STATUS_LONGJUMP: NTSTATUS = NTSTATUS(-2147483610i32 as _);
pub const STATUS_LOST_MODE_LOGON_RESTRICTION: NTSTATUS = NTSTATUS(-1073741043i32 as _);
pub const STATUS_LOST_WRITEBEHIND_DATA: NTSTATUS = NTSTATUS(-1073741278i32 as _);
pub const STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR: NTSTATUS = NTSTATUS(-1073700734i32 as _);
pub const STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED: NTSTATUS = NTSTATUS(-1073700736i32 as _);
pub const STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR: NTSTATUS = NTSTATUS(-1073700735i32 as _);
pub const STATUS_LPAC_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1073700349i32 as _);
pub const STATUS_LPC_HANDLE_COUNT_EXCEEDED: NTSTATUS = NTSTATUS(-1073739998i32 as _);
pub const STATUS_LPC_INVALID_CONNECTION_USAGE: NTSTATUS = NTSTATUS(-1073740026i32 as _);
pub const STATUS_LPC_RECEIVE_BUFFER_EXPECTED: NTSTATUS = NTSTATUS(-1073740027i32 as _);
pub const STATUS_LPC_REPLY_LOST: NTSTATUS = NTSTATUS(-1073741229i32 as _);
pub const STATUS_LPC_REQUESTS_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1073740025i32 as _);
pub const STATUS_LUIDS_EXHAUSTED: NTSTATUS = NTSTATUS(-1073741707i32 as _);
pub const STATUS_MAGAZINE_NOT_PRESENT: NTSTATUS = NTSTATUS(-1073741178i32 as _);
pub const STATUS_MAPPED_ALIGNMENT: NTSTATUS = NTSTATUS(-1073741280i32 as _);
pub const STATUS_MAPPED_FILE_SIZE_ZERO: NTSTATUS = NTSTATUS(-1073741538i32 as _);
pub const STATUS_MARKED_TO_DISALLOW_WRITES: NTSTATUS = NTSTATUS(-1073740659i32 as _);
pub const STATUS_MARSHALL_OVERFLOW: NTSTATUS = NTSTATUS(-1073741263i32 as _);
pub const STATUS_MAX_REFERRALS_EXCEEDED: NTSTATUS = NTSTATUS(-1073741068i32 as _);
pub const STATUS_MCA_EXCEPTION: NTSTATUS = NTSTATUS(-1073740013i32 as _);
pub const STATUS_MCA_OCCURED: NTSTATUS = NTSTATUS(-1073740950i32 as _);
pub const STATUS_MEDIA_CHANGED: NTSTATUS = NTSTATUS(-2147483620i32 as _);
pub const STATUS_MEDIA_CHECK: NTSTATUS = NTSTATUS(-2147483616i32 as _);
pub const STATUS_MEDIA_WRITE_PROTECTED: NTSTATUS = NTSTATUS(-1073741662i32 as _);
pub const STATUS_MEMBERS_PRIMARY_GROUP: NTSTATUS = NTSTATUS(-1073741529i32 as _);
pub const STATUS_MEMBER_IN_ALIAS: NTSTATUS = NTSTATUS(-1073741485i32 as _);
pub const STATUS_MEMBER_IN_GROUP: NTSTATUS = NTSTATUS(-1073741721i32 as _);
pub const STATUS_MEMBER_NOT_IN_ALIAS: NTSTATUS = NTSTATUS(-1073741486i32 as _);
pub const STATUS_MEMBER_NOT_IN_GROUP: NTSTATUS = NTSTATUS(-1073741720i32 as _);
pub const STATUS_MEMORY_NOT_ALLOCATED: NTSTATUS = NTSTATUS(-1073741664i32 as _);
pub const STATUS_MESSAGE_LOST: NTSTATUS = NTSTATUS(-1073740031i32 as _);
pub const STATUS_MESSAGE_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741559i32 as _);
pub const STATUS_MESSAGE_RETRIEVED: NTSTATUS = NTSTATUS(1073741870i32 as _);
pub const STATUS_MFT_TOO_FRAGMENTED: NTSTATUS = NTSTATUS(-1073741052i32 as _);
pub const STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION: NTSTATUS = NTSTATUS(-1072103388i32 as _);
pub const STATUS_MISSING_SYSTEMFILE: NTSTATUS = NTSTATUS(-1073741501i32 as _);
pub const STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM: NTSTATUS = NTSTATUS(-1071841277i32 as _);
pub const STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK: NTSTATUS = NTSTATUS(-1071841271i32 as _);
pub const STATUS_MONITOR_INVALID_MANUFACTURE_DATE: NTSTATUS = NTSTATUS(-1071841270i32 as _);
pub const STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK: NTSTATUS = NTSTATUS(-1071841274i32 as _);
pub const STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK: NTSTATUS = NTSTATUS(-1071841276i32 as _);
pub const STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK: NTSTATUS = NTSTATUS(-1071841273i32 as _);
pub const STATUS_MONITOR_NO_DESCRIPTOR: NTSTATUS = NTSTATUS(-1071841279i32 as _);
pub const STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA: NTSTATUS = NTSTATUS(-1071841272i32 as _);
pub const STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT: NTSTATUS = NTSTATUS(-1071841278i32 as _);
pub const STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED: NTSTATUS = NTSTATUS(-1071841275i32 as _);
pub const STATUS_MORE_ENTRIES: NTSTATUS = NTSTATUS(261i32 as _);
pub const STATUS_MORE_PROCESSING_REQUIRED: NTSTATUS = NTSTATUS(-1073741802i32 as _);
pub const STATUS_MOUNT_POINT_NOT_RESOLVED: NTSTATUS = NTSTATUS(-1073740952i32 as _);
pub const STATUS_MP_PROCESSOR_MISMATCH: NTSTATUS = NTSTATUS(1073741865i32 as _);
pub const STATUS_MUI_FILE_NOT_FOUND: NTSTATUS = NTSTATUS(-1073020927i32 as _);
pub const STATUS_MUI_FILE_NOT_LOADED: NTSTATUS = NTSTATUS(-1073020922i32 as _);
pub const STATUS_MUI_INVALID_FILE: NTSTATUS = NTSTATUS(-1073020926i32 as _);
pub const STATUS_MUI_INVALID_LOCALE_NAME: NTSTATUS = NTSTATUS(-1073020924i32 as _);
pub const STATUS_MUI_INVALID_RC_CONFIG: NTSTATUS = NTSTATUS(-1073020925i32 as _);
pub const STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME: NTSTATUS = NTSTATUS(-1073020923i32 as _);
pub const STATUS_MULTIPLE_FAULT_VIOLATION: NTSTATUS = NTSTATUS(-1073741080i32 as _);
pub const STATUS_MUST_BE_KDC: NTSTATUS = NTSTATUS(-1073741067i32 as _);
pub const STATUS_MUTANT_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1073741423i32 as _);
pub const STATUS_MUTANT_NOT_OWNED: NTSTATUS = NTSTATUS(-1073741754i32 as _);
pub const STATUS_MUTUAL_AUTHENTICATION_FAILED: NTSTATUS = NTSTATUS(-1073741117i32 as _);
pub const STATUS_NAME_TOO_LONG: NTSTATUS = NTSTATUS(-1073741562i32 as _);
pub const STATUS_NDIS_ADAPTER_NOT_FOUND: NTSTATUS = NTSTATUS(-1071448058i32 as _);
pub const STATUS_NDIS_ADAPTER_NOT_READY: NTSTATUS = NTSTATUS(-1071448047i32 as _);
pub const STATUS_NDIS_ADAPTER_REMOVED: NTSTATUS = NTSTATUS(-1071448040i32 as _);
pub const STATUS_NDIS_ALREADY_MAPPED: NTSTATUS = NTSTATUS(-1071448035i32 as _);
pub const STATUS_NDIS_BAD_CHARACTERISTICS: NTSTATUS = NTSTATUS(-1071448059i32 as _);
pub const STATUS_NDIS_BAD_VERSION: NTSTATUS = NTSTATUS(-1071448060i32 as _);
pub const STATUS_NDIS_BUFFER_TOO_SHORT: NTSTATUS = NTSTATUS(-1071448042i32 as _);
pub const STATUS_NDIS_CLOSING: NTSTATUS = NTSTATUS(-1071448062i32 as _);
pub const STATUS_NDIS_DEVICE_FAILED: NTSTATUS = NTSTATUS(-1071448056i32 as _);
pub const STATUS_NDIS_DOT11_AP_BAND_CURRENTLY_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1071439866i32 as _);
pub const STATUS_NDIS_DOT11_AP_BAND_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1071439864i32 as _);
pub const STATUS_NDIS_DOT11_AP_CHANNEL_CURRENTLY_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1071439867i32 as _);
pub const STATUS_NDIS_DOT11_AP_CHANNEL_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1071439865i32 as _);
pub const STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED: NTSTATUS = NTSTATUS(-1071439872i32 as _);
pub const STATUS_NDIS_DOT11_MEDIA_IN_USE: NTSTATUS = NTSTATUS(-1071439871i32 as _);
pub const STATUS_NDIS_DOT11_POWER_STATE_INVALID: NTSTATUS = NTSTATUS(-1071439870i32 as _);
pub const STATUS_NDIS_ERROR_READING_FILE: NTSTATUS = NTSTATUS(-1071448036i32 as _);
pub const STATUS_NDIS_FILE_NOT_FOUND: NTSTATUS = NTSTATUS(-1071448037i32 as _);
pub const STATUS_NDIS_GROUP_ADDRESS_IN_USE: NTSTATUS = NTSTATUS(-1071448038i32 as _);
pub const STATUS_NDIS_INDICATION_REQUIRED: NTSTATUS = NTSTATUS(1076035585i32 as _);
pub const STATUS_NDIS_INTERFACE_NOT_FOUND: NTSTATUS = NTSTATUS(-1071448021i32 as _);
pub const STATUS_NDIS_INVALID_ADDRESS: NTSTATUS = NTSTATUS(-1071448030i32 as _);
pub const STATUS_NDIS_INVALID_DATA: NTSTATUS = NTSTATUS(-1071448043i32 as _);
pub const STATUS_NDIS_INVALID_DEVICE_REQUEST: NTSTATUS = NTSTATUS(-1071448048i32 as _);
pub const STATUS_NDIS_INVALID_LENGTH: NTSTATUS = NTSTATUS(-1071448044i32 as _);
pub const STATUS_NDIS_INVALID_OID: NTSTATUS = NTSTATUS(-1071448041i32 as _);
pub const STATUS_NDIS_INVALID_PACKET: NTSTATUS = NTSTATUS(-1071448049i32 as _);
pub const STATUS_NDIS_INVALID_PORT: NTSTATUS = NTSTATUS(-1071448019i32 as _);
pub const STATUS_NDIS_INVALID_PORT_STATE: NTSTATUS = NTSTATUS(-1071448018i32 as _);
pub const STATUS_NDIS_LOW_POWER_STATE: NTSTATUS = NTSTATUS(-1071448017i32 as _);
pub const STATUS_NDIS_MEDIA_DISCONNECTED: NTSTATUS = NTSTATUS(-1071448033i32 as _);
pub const STATUS_NDIS_MULTICAST_EXISTS: NTSTATUS = NTSTATUS(-1071448054i32 as _);
pub const STATUS_NDIS_MULTICAST_FULL: NTSTATUS = NTSTATUS(-1071448055i32 as _);
pub const STATUS_NDIS_MULTICAST_NOT_FOUND: NTSTATUS = NTSTATUS(-1071448053i32 as _);
pub const STATUS_NDIS_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071447877i32 as _);
pub const STATUS_NDIS_NO_QUEUES: NTSTATUS = NTSTATUS(-1071448015i32 as _);
pub const STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED: NTSTATUS = NTSTATUS(-1071443950i32 as _);
pub const STATUS_NDIS_OFFLOAD_PATH_REJECTED: NTSTATUS = NTSTATUS(-1071443949i32 as _);
pub const STATUS_NDIS_OFFLOAD_POLICY: NTSTATUS = NTSTATUS(-1071443953i32 as _);
pub const STATUS_NDIS_OPEN_FAILED: NTSTATUS = NTSTATUS(-1071448057i32 as _);
pub const STATUS_NDIS_PAUSED: NTSTATUS = NTSTATUS(-1071448022i32 as _);
pub const STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL: NTSTATUS = NTSTATUS(-1071439868i32 as _);
pub const STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL: NTSTATUS = NTSTATUS(-1071439869i32 as _);
pub const STATUS_NDIS_REINIT_REQUIRED: NTSTATUS = NTSTATUS(-1071448016i32 as _);
pub const STATUS_NDIS_REQUEST_ABORTED: NTSTATUS = NTSTATUS(-1071448052i32 as _);
pub const STATUS_NDIS_RESET_IN_PROGRESS: NTSTATUS = NTSTATUS(-1071448051i32 as _);
pub const STATUS_NDIS_RESOURCE_CONFLICT: NTSTATUS = NTSTATUS(-1071448034i32 as _);
pub const STATUS_NDIS_UNSUPPORTED_MEDIA: NTSTATUS = NTSTATUS(-1071448039i32 as _);
pub const STATUS_NDIS_UNSUPPORTED_REVISION: NTSTATUS = NTSTATUS(-1071448020i32 as _);
pub const STATUS_ND_QUEUE_OVERFLOW: NTSTATUS = NTSTATUS(-1073700847i32 as _);
pub const STATUS_NEEDS_REGISTRATION: NTSTATUS = NTSTATUS(-1073740663i32 as _);
pub const STATUS_NEEDS_REMEDIATION: NTSTATUS = NTSTATUS(-1073740702i32 as _);
pub const STATUS_NETLOGON_NOT_STARTED: NTSTATUS = NTSTATUS(-1073741422i32 as _);
pub const STATUS_NETWORK_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1073741622i32 as _);
pub const STATUS_NETWORK_ACCESS_DENIED_EDP: NTSTATUS = NTSTATUS(-1073740658i32 as _);
pub const STATUS_NETWORK_BUSY: NTSTATUS = NTSTATUS(-1073741633i32 as _);
pub const STATUS_NETWORK_CREDENTIAL_CONFLICT: NTSTATUS = NTSTATUS(-1073741419i32 as _);
pub const STATUS_NETWORK_NAME_DELETED: NTSTATUS = NTSTATUS(-1073741623i32 as _);
pub const STATUS_NETWORK_OPEN_RESTRICTION: NTSTATUS = NTSTATUS(-1073741311i32 as _);
pub const STATUS_NETWORK_SESSION_EXPIRED: NTSTATUS = NTSTATUS(-1073740964i32 as _);
pub const STATUS_NETWORK_UNREACHABLE: NTSTATUS = NTSTATUS(-1073741252i32 as _);
pub const STATUS_NET_WRITE_FAULT: NTSTATUS = NTSTATUS(-1073741614i32 as _);
pub const STATUS_NOINTERFACE: NTSTATUS = NTSTATUS(-1073741127i32 as _);
pub const STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT: NTSTATUS = NTSTATUS(-1073741416i32 as _);
pub const STATUS_NOLOGON_SERVER_TRUST_ACCOUNT: NTSTATUS = NTSTATUS(-1073741414i32 as _);
pub const STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT: NTSTATUS = NTSTATUS(-1073741415i32 as _);
pub const STATUS_NONCONTINUABLE_EXCEPTION: NTSTATUS = NTSTATUS(-1073741787i32 as _);
pub const STATUS_NONEXISTENT_EA_ENTRY: NTSTATUS = NTSTATUS(-1073741743i32 as _);
pub const STATUS_NONEXISTENT_SECTOR: NTSTATUS = NTSTATUS(-1073741803i32 as _);
pub const STATUS_NONE_MAPPED: NTSTATUS = NTSTATUS(-1073741709i32 as _);
pub const STATUS_NOTHING_TO_TERMINATE: NTSTATUS = NTSTATUS(290i32 as _);
pub const STATUS_NOTIFICATION_GUID_ALREADY_DEFINED: NTSTATUS = NTSTATUS(-1073741404i32 as _);
pub const STATUS_NOTIFY_CLEANUP: NTSTATUS = NTSTATUS(267i32 as _);
pub const STATUS_NOTIFY_ENUM_DIR: NTSTATUS = NTSTATUS(268i32 as _);
pub const STATUS_NOT_ALLOWED_ON_SYSTEM_FILE: NTSTATUS = NTSTATUS(-1073741401i32 as _);
pub const STATUS_NOT_ALL_ASSIGNED: NTSTATUS = NTSTATUS(262i32 as _);
pub const STATUS_NOT_APPCONTAINER: NTSTATUS = NTSTATUS(-1073700352i32 as _);
pub const STATUS_NOT_A_CLOUD_FILE: NTSTATUS = NTSTATUS(-1073688825i32 as _);
pub const STATUS_NOT_A_CLOUD_SYNC_ROOT: NTSTATUS = NTSTATUS(-1073688802i32 as _);
pub const STATUS_NOT_A_DAX_VOLUME: NTSTATUS = NTSTATUS(-1073740623i32 as _);
pub const STATUS_NOT_A_DIRECTORY: NTSTATUS = NTSTATUS(-1073741565i32 as _);
pub const STATUS_NOT_A_REPARSE_POINT: NTSTATUS = NTSTATUS(-1073741195i32 as _);
pub const STATUS_NOT_A_TIERED_VOLUME: NTSTATUS = NTSTATUS(-1073740531i32 as _);
pub const STATUS_NOT_CAPABLE: NTSTATUS = NTSTATUS(-1073740759i32 as _);
pub const STATUS_NOT_CLIENT_SESSION: NTSTATUS = NTSTATUS(-1073741289i32 as _);
pub const STATUS_NOT_COMMITTED: NTSTATUS = NTSTATUS(-1073741779i32 as _);
pub const STATUS_NOT_DAX_MAPPABLE: NTSTATUS = NTSTATUS(-1073740622i32 as _);
pub const STATUS_NOT_EXPORT_FORMAT: NTSTATUS = NTSTATUS(-1073741166i32 as _);
pub const STATUS_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741275i32 as _);
pub const STATUS_NOT_GUI_PROCESS: NTSTATUS = NTSTATUS(-1073740538i32 as _);
pub const STATUS_NOT_IMPLEMENTED: NTSTATUS = NTSTATUS(-1073741822i32 as _);
pub const STATUS_NOT_LOCKED: NTSTATUS = NTSTATUS(-1073741782i32 as _);
pub const STATUS_NOT_LOGON_PROCESS: NTSTATUS = NTSTATUS(-1073741587i32 as _);
pub const STATUS_NOT_MAPPED_DATA: NTSTATUS = NTSTATUS(-1073741688i32 as _);
pub const STATUS_NOT_MAPPED_VIEW: NTSTATUS = NTSTATUS(-1073741799i32 as _);
pub const STATUS_NOT_READ_FROM_COPY: NTSTATUS = NTSTATUS(-1073740694i32 as _);
pub const STATUS_NOT_REDUNDANT_STORAGE: NTSTATUS = NTSTATUS(-1073740679i32 as _);
pub const STATUS_NOT_REGISTRY_FILE: NTSTATUS = NTSTATUS(-1073741476i32 as _);
pub const STATUS_NOT_SAFE_MODE_DRIVER: NTSTATUS = NTSTATUS(-1073740961i32 as _);
pub const STATUS_NOT_SAME_DEVICE: NTSTATUS = NTSTATUS(-1073741612i32 as _);
pub const STATUS_NOT_SAME_OBJECT: NTSTATUS = NTSTATUS(-1073741396i32 as _);
pub const STATUS_NOT_SERVER_SESSION: NTSTATUS = NTSTATUS(-1073741290i32 as _);
pub const STATUS_NOT_SNAPSHOT_VOLUME: NTSTATUS = NTSTATUS(-1072103353i32 as _);
pub const STATUS_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073741637i32 as _);
pub const STATUS_NOT_SUPPORTED_IN_APPCONTAINER: NTSTATUS = NTSTATUS(-1073700351i32 as _);
pub const STATUS_NOT_SUPPORTED_ON_DAX: NTSTATUS = NTSTATUS(-1073740646i32 as _);
pub const STATUS_NOT_SUPPORTED_ON_SBS: NTSTATUS = NTSTATUS(-1073741056i32 as _);
pub const STATUS_NOT_SUPPORTED_WITH_AUDITING: NTSTATUS = NTSTATUS(-1073740595i32 as _);
pub const STATUS_NOT_SUPPORTED_WITH_BTT: NTSTATUS = NTSTATUS(-1073740619i32 as _);
pub const STATUS_NOT_SUPPORTED_WITH_BYPASSIO: NTSTATUS = NTSTATUS(-1073740601i32 as _);
pub const STATUS_NOT_SUPPORTED_WITH_COMPRESSION: NTSTATUS = NTSTATUS(-1073740598i32 as _);
pub const STATUS_NOT_SUPPORTED_WITH_DEDUPLICATION: NTSTATUS = NTSTATUS(-1073740596i32 as _);
pub const STATUS_NOT_SUPPORTED_WITH_ENCRYPTION: NTSTATUS = NTSTATUS(-1073740599i32 as _);
pub const STATUS_NOT_SUPPORTED_WITH_MONITORING: NTSTATUS = NTSTATUS(-1073740594i32 as _);
pub const STATUS_NOT_SUPPORTED_WITH_REPLICATION: NTSTATUS = NTSTATUS(-1073740597i32 as _);
pub const STATUS_NOT_SUPPORTED_WITH_SNAPSHOT: NTSTATUS = NTSTATUS(-1073740593i32 as _);
pub const STATUS_NOT_SUPPORTED_WITH_VIRTUALIZATION: NTSTATUS = NTSTATUS(-1073740592i32 as _);
pub const STATUS_NOT_TINY_STREAM: NTSTATUS = NTSTATUS(-1073741274i32 as _);
pub const STATUS_NO_ACE_CONDITION: NTSTATUS = NTSTATUS(-2147483601i32 as _);
pub const STATUS_NO_APPLICABLE_APP_LICENSES_FOUND: NTSTATUS = NTSTATUS(-1058406399i32 as _);
pub const STATUS_NO_APPLICATION_PACKAGE: NTSTATUS = NTSTATUS(-1073741398i32 as _);
pub const STATUS_NO_BROWSER_SERVERS_FOUND: NTSTATUS = NTSTATUS(-1073741284i32 as _);
pub const STATUS_NO_BYPASSIO_DRIVER_SUPPORT: NTSTATUS = NTSTATUS(-1073740600i32 as _);
pub const STATUS_NO_CALLBACK_ACTIVE: NTSTATUS = NTSTATUS(-1073741224i32 as _);
pub const STATUS_NO_DATA_DETECTED: NTSTATUS = NTSTATUS(-2147483614i32 as _);
pub const STATUS_NO_EAS_ON_FILE: NTSTATUS = NTSTATUS(-1073741742i32 as _);
pub const STATUS_NO_EFS: NTSTATUS = NTSTATUS(-1073741170i32 as _);
pub const STATUS_NO_EVENT_PAIR: NTSTATUS = NTSTATUS(-1073741490i32 as _);
pub const STATUS_NO_GUID_TRANSLATION: NTSTATUS = NTSTATUS(-1073741556i32 as _);
pub const STATUS_NO_IMPERSONATION_TOKEN: NTSTATUS = NTSTATUS(-1073741732i32 as _);
pub const STATUS_NO_INHERITANCE: NTSTATUS = NTSTATUS(-2147483637i32 as _);
pub const STATUS_NO_IP_ADDRESSES: NTSTATUS = NTSTATUS(-1073741071i32 as _);
pub const STATUS_NO_KERB_KEY: NTSTATUS = NTSTATUS(-1073741022i32 as _);
pub const STATUS_NO_KEY: NTSTATUS = NTSTATUS(-1073739508i32 as _);
pub const STATUS_NO_LDT: NTSTATUS = NTSTATUS(-1073741545i32 as _);
pub const STATUS_NO_LINK_TRACKING_IN_TRANSACTION: NTSTATUS = NTSTATUS(-1072103335i32 as _);
pub const STATUS_NO_LOGON_SERVERS: NTSTATUS = NTSTATUS(-1073741730i32 as _);
pub const STATUS_NO_LOG_SPACE: NTSTATUS = NTSTATUS(-1073741443i32 as _);
pub const STATUS_NO_MATCH: NTSTATUS = NTSTATUS(-1073741198i32 as _);
pub const STATUS_NO_MEDIA: NTSTATUS = NTSTATUS(-1073741448i32 as _);
pub const STATUS_NO_MEDIA_IN_DEVICE: NTSTATUS = NTSTATUS(-1073741805i32 as _);
pub const STATUS_NO_MEMORY: NTSTATUS = NTSTATUS(-1073741801i32 as _);
pub const STATUS_NO_MORE_EAS: NTSTATUS = NTSTATUS(-2147483630i32 as _);
pub const STATUS_NO_MORE_ENTRIES: NTSTATUS = NTSTATUS(-2147483622i32 as _);
pub const STATUS_NO_MORE_FILES: NTSTATUS = NTSTATUS(-2147483642i32 as _);
pub const STATUS_NO_MORE_MATCHES: NTSTATUS = NTSTATUS(-1073741197i32 as _);
pub const STATUS_NO_PAGEFILE: NTSTATUS = NTSTATUS(-1073741497i32 as _);
pub const STATUS_NO_PA_DATA: NTSTATUS = NTSTATUS(-1073741064i32 as _);
pub const STATUS_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND: NTSTATUS = NTSTATUS(-1073740635i32 as _);
pub const STATUS_NO_QUOTAS_FOR_ACCOUNT: NTSTATUS = NTSTATUS(269i32 as _);
pub const STATUS_NO_RANGES_PROCESSED: NTSTATUS = NTSTATUS(-1073740704i32 as _);
pub const STATUS_NO_RECOVERY_POLICY: NTSTATUS = NTSTATUS(-1073741171i32 as _);
pub const STATUS_NO_S4U_PROT_SUPPORT: NTSTATUS = NTSTATUS(-1073740790i32 as _);
pub const STATUS_NO_SAVEPOINT_WITH_OPEN_FILES: NTSTATUS = NTSTATUS(-1072103352i32 as _);
pub const STATUS_NO_SECRETS: NTSTATUS = NTSTATUS(-1073740943i32 as _);
pub const STATUS_NO_SECURITY_CONTEXT: NTSTATUS = NTSTATUS(-1073740755i32 as _);
pub const STATUS_NO_SECURITY_ON_OBJECT: NTSTATUS = NTSTATUS(-1073741609i32 as _);
pub const STATUS_NO_SPOOL_SPACE: NTSTATUS = NTSTATUS(-1073741625i32 as _);
pub const STATUS_NO_SUCH_ALIAS: NTSTATUS = NTSTATUS(-1073741487i32 as _);
pub const STATUS_NO_SUCH_DEVICE: NTSTATUS = NTSTATUS(-1073741810i32 as _);
pub const STATUS_NO_SUCH_DOMAIN: NTSTATUS = NTSTATUS(-1073741601i32 as _);
pub const STATUS_NO_SUCH_FILE: NTSTATUS = NTSTATUS(-1073741809i32 as _);
pub const STATUS_NO_SUCH_GROUP: NTSTATUS = NTSTATUS(-1073741722i32 as _);
pub const STATUS_NO_SUCH_MEMBER: NTSTATUS = NTSTATUS(-1073741446i32 as _);
pub const STATUS_NO_SUCH_PACKAGE: NTSTATUS = NTSTATUS(-1073741570i32 as _);
pub const STATUS_NO_SUCH_PRIVILEGE: NTSTATUS = NTSTATUS(-1073741728i32 as _);
pub const STATUS_NO_TGT_REPLY: NTSTATUS = NTSTATUS(-1073741073i32 as _);
pub const STATUS_NO_TOKEN: NTSTATUS = NTSTATUS(-1073741700i32 as _);
pub const STATUS_NO_TRACKING_SERVICE: NTSTATUS = NTSTATUS(-1073741153i32 as _);
pub const STATUS_NO_TRUST_LSA_SECRET: NTSTATUS = NTSTATUS(-1073741430i32 as _);
pub const STATUS_NO_TRUST_SAM_ACCOUNT: NTSTATUS = NTSTATUS(-1073741429i32 as _);
pub const STATUS_NO_TXF_METADATA: NTSTATUS = NTSTATUS(-2145845207i32 as _);
pub const STATUS_NO_UNICODE_TRANSLATION: NTSTATUS = NTSTATUS(-1073740009i32 as _);
pub const STATUS_NO_USER_KEYS: NTSTATUS = NTSTATUS(-1073741168i32 as _);
pub const STATUS_NO_USER_SESSION_KEY: NTSTATUS = NTSTATUS(-1073741310i32 as _);
pub const STATUS_NO_WORK_DONE: NTSTATUS = NTSTATUS(-2147483598i32 as _);
pub const STATUS_NO_YIELD_PERFORMED: NTSTATUS = NTSTATUS(1073741860i32 as _);
pub const STATUS_NTLM_BLOCKED: NTSTATUS = NTSTATUS(-1073740776i32 as _);
pub const STATUS_NT_CROSS_ENCRYPTION_REQUIRED: NTSTATUS = NTSTATUS(-1073741475i32 as _);
pub const STATUS_NULL_LM_PASSWORD: NTSTATUS = NTSTATUS(1073741837i32 as _);
pub const STATUS_OBJECTID_EXISTS: NTSTATUS = NTSTATUS(-1073741269i32 as _);
pub const STATUS_OBJECTID_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741072i32 as _);
pub const STATUS_OBJECT_IS_IMMUTABLE: NTSTATUS = NTSTATUS(-1073740610i32 as _);
pub const STATUS_OBJECT_NAME_COLLISION: NTSTATUS = NTSTATUS(-1073741771i32 as _);
pub const STATUS_OBJECT_NAME_EXISTS: NTSTATUS = NTSTATUS(1073741824i32 as _);
pub const STATUS_OBJECT_NAME_INVALID: NTSTATUS = NTSTATUS(-1073741773i32 as _);
pub const STATUS_OBJECT_NAME_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741772i32 as _);
pub const STATUS_OBJECT_NOT_EXTERNALLY_BACKED: NTSTATUS = NTSTATUS(-1073740691i32 as _);
pub const STATUS_OBJECT_NO_LONGER_EXISTS: NTSTATUS = NTSTATUS(-1072103391i32 as _);
pub const STATUS_OBJECT_PATH_INVALID: NTSTATUS = NTSTATUS(-1073741767i32 as _);
pub const STATUS_OBJECT_PATH_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741766i32 as _);
pub const STATUS_OBJECT_PATH_SYNTAX_BAD: NTSTATUS = NTSTATUS(-1073741765i32 as _);
pub const STATUS_OBJECT_TYPE_MISMATCH: NTSTATUS = NTSTATUS(-1073741788i32 as _);
pub const STATUS_OFFLOAD_READ_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073700189i32 as _);
pub const STATUS_OFFLOAD_READ_FLT_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073700191i32 as _);
pub const STATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073700188i32 as _);
pub const STATUS_OFFLOAD_WRITE_FLT_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073700190i32 as _);
pub const STATUS_ONLY_IF_CONNECTED: NTSTATUS = NTSTATUS(-1073741108i32 as _);
pub const STATUS_OPEN_FAILED: NTSTATUS = NTSTATUS(-1073741514i32 as _);
pub const STATUS_OPERATION_IN_PROGRESS: NTSTATUS = NTSTATUS(-1073740682i32 as _);
pub const STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION: NTSTATUS = NTSTATUS(-1072103334i32 as _);
pub const STATUS_OPLOCK_BREAK_IN_PROGRESS: NTSTATUS = NTSTATUS(264i32 as _);
pub const STATUS_OPLOCK_HANDLE_CLOSED: NTSTATUS = NTSTATUS(534i32 as _);
pub const STATUS_OPLOCK_NOT_GRANTED: NTSTATUS = NTSTATUS(-1073741598i32 as _);
pub const STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE: NTSTATUS = NTSTATUS(533i32 as _);
pub const STATUS_ORDINAL_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741512i32 as _);
pub const STATUS_ORPHAN_NAME_EXHAUSTED: NTSTATUS = NTSTATUS(-1073739762i32 as _);
pub const STATUS_PACKAGE_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1073740649i32 as _);
pub const STATUS_PACKAGE_UPDATING: NTSTATUS = NTSTATUS(-1073740695i32 as _);
pub const STATUS_PAGEFILE_CREATE_FAILED: NTSTATUS = NTSTATUS(-1073741498i32 as _);
pub const STATUS_PAGEFILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073740603i32 as _);
pub const STATUS_PAGEFILE_QUOTA: NTSTATUS = NTSTATUS(-1073741817i32 as _);
pub const STATUS_PAGEFILE_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1073741524i32 as _);
pub const STATUS_PAGE_FAULT_COPY_ON_WRITE: NTSTATUS = NTSTATUS(274i32 as _);
pub const STATUS_PAGE_FAULT_DEMAND_ZERO: NTSTATUS = NTSTATUS(273i32 as _);
pub const STATUS_PAGE_FAULT_GUARD_PAGE: NTSTATUS = NTSTATUS(275i32 as _);
pub const STATUS_PAGE_FAULT_PAGING_FILE: NTSTATUS = NTSTATUS(276i32 as _);
pub const STATUS_PAGE_FAULT_TRANSITION: NTSTATUS = NTSTATUS(272i32 as _);
pub const STATUS_PARAMETER_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1073740784i32 as _);
pub const STATUS_PARITY_ERROR: NTSTATUS = NTSTATUS(-1073741781i32 as _);
pub const STATUS_PARTIAL_COPY: NTSTATUS = NTSTATUS(-2147483635i32 as _);
pub const STATUS_PARTITION_FAILURE: NTSTATUS = NTSTATUS(-1073741454i32 as _);
pub const STATUS_PARTITION_TERMINATING: NTSTATUS = NTSTATUS(-1073740640i32 as _);
pub const STATUS_PASSWORD_CHANGE_REQUIRED: NTSTATUS = NTSTATUS(-1073741044i32 as _);
pub const STATUS_PASSWORD_RESTRICTION: NTSTATUS = NTSTATUS(-1073741716i32 as _);
pub const STATUS_PATCH_CONFLICT: NTSTATUS = NTSTATUS(-1073740628i32 as _);
pub const STATUS_PATCH_DEFERRED: NTSTATUS = NTSTATUS(1073741879i32 as _);
pub const STATUS_PATH_NOT_COVERED: NTSTATUS = NTSTATUS(-1073741225i32 as _);
pub const STATUS_PCP_ATTESTATION_CHALLENGE_NOT_SET: NTSTATUS = NTSTATUS(-1071046638i32 as _);
pub const STATUS_PCP_AUTHENTICATION_FAILED: NTSTATUS = NTSTATUS(-1071046648i32 as _);
pub const STATUS_PCP_AUTHENTICATION_IGNORED: NTSTATUS = NTSTATUS(-1071046647i32 as _);
pub const STATUS_PCP_BUFFER_LENGTH_MISMATCH: NTSTATUS = NTSTATUS(-1071046626i32 as _);
pub const STATUS_PCP_BUFFER_TOO_SMALL: NTSTATUS = NTSTATUS(-1071046650i32 as _);
pub const STATUS_PCP_CLAIM_TYPE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071046628i32 as _);
pub const STATUS_PCP_DEVICE_NOT_FOUND: NTSTATUS = NTSTATUS(-1071046643i32 as _);
pub const STATUS_PCP_DEVICE_NOT_READY: NTSTATUS = NTSTATUS(-1071046655i32 as _);
pub const STATUS_PCP_ERROR_MASK: NTSTATUS = NTSTATUS(-1071046656i32 as _);
pub const STATUS_PCP_FLAG_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071046652i32 as _);
pub const STATUS_PCP_IFX_RSA_KEY_CREATION_BLOCKED: NTSTATUS = NTSTATUS(-1071046625i32 as _);
pub const STATUS_PCP_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1071046649i32 as _);
pub const STATUS_PCP_INVALID_HANDLE: NTSTATUS = NTSTATUS(-1071046654i32 as _);
pub const STATUS_PCP_INVALID_PARAMETER: NTSTATUS = NTSTATUS(-1071046653i32 as _);
pub const STATUS_PCP_KEY_ALREADY_FINALIZED: NTSTATUS = NTSTATUS(-1071046636i32 as _);
pub const STATUS_PCP_KEY_HANDLE_INVALIDATED: NTSTATUS = NTSTATUS(-1071046622i32 as _);
pub const STATUS_PCP_KEY_NOT_AIK: NTSTATUS = NTSTATUS(-1071046631i32 as _);
pub const STATUS_PCP_KEY_NOT_AUTHENTICATED: NTSTATUS = NTSTATUS(-1071046632i32 as _);
pub const STATUS_PCP_KEY_NOT_FINALIZED: NTSTATUS = NTSTATUS(-1071046639i32 as _);
pub const STATUS_PCP_KEY_NOT_LOADED: NTSTATUS = NTSTATUS(-1071046641i32 as _);
pub const STATUS_PCP_KEY_NOT_SIGNING_KEY: NTSTATUS = NTSTATUS(-1071046630i32 as _);
pub const STATUS_PCP_KEY_USAGE_POLICY_INVALID: NTSTATUS = NTSTATUS(-1071046634i32 as _);
pub const STATUS_PCP_KEY_USAGE_POLICY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071046635i32 as _);
pub const STATUS_PCP_LOCKED_OUT: NTSTATUS = NTSTATUS(-1071046629i32 as _);
pub const STATUS_PCP_NOT_PCR_BOUND: NTSTATUS = NTSTATUS(-1071046637i32 as _);
pub const STATUS_PCP_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071046651i32 as _);
pub const STATUS_PCP_NO_KEY_CERTIFICATION: NTSTATUS = NTSTATUS(-1071046640i32 as _);
pub const STATUS_PCP_POLICY_NOT_FOUND: NTSTATUS = NTSTATUS(-1071046646i32 as _);
pub const STATUS_PCP_PROFILE_NOT_FOUND: NTSTATUS = NTSTATUS(-1071046645i32 as _);
pub const STATUS_PCP_RAW_POLICY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071046623i32 as _);
pub const STATUS_PCP_SOFT_KEY_ERROR: NTSTATUS = NTSTATUS(-1071046633i32 as _);
pub const STATUS_PCP_TICKET_MISSING: NTSTATUS = NTSTATUS(-1071046624i32 as _);
pub const STATUS_PCP_TPM_VERSION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1071046627i32 as _);
pub const STATUS_PCP_UNSUPPORTED_PSS_SALT: NTSTATUS = NTSTATUS(1076437027i32 as _);
pub const STATUS_PCP_VALIDATION_FAILED: NTSTATUS = NTSTATUS(-1071046644i32 as _);
pub const STATUS_PCP_WRONG_PARENT: NTSTATUS = NTSTATUS(-1071046642i32 as _);
pub const STATUS_PENDING: NTSTATUS = NTSTATUS(259i32 as _);
pub const STATUS_PER_USER_TRUST_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1073740799i32 as _);
pub const STATUS_PIPE_BROKEN: NTSTATUS = NTSTATUS(-1073741493i32 as _);
pub const STATUS_PIPE_BUSY: NTSTATUS = NTSTATUS(-1073741650i32 as _);
pub const STATUS_PIPE_CLOSING: NTSTATUS = NTSTATUS(-1073741647i32 as _);
pub const STATUS_PIPE_CONNECTED: NTSTATUS = NTSTATUS(-1073741646i32 as _);
pub const STATUS_PIPE_DISCONNECTED: NTSTATUS = NTSTATUS(-1073741648i32 as _);
pub const STATUS_PIPE_EMPTY: NTSTATUS = NTSTATUS(-1073741607i32 as _);
pub const STATUS_PIPE_LISTENING: NTSTATUS = NTSTATUS(-1073741645i32 as _);
pub const STATUS_PIPE_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1073741652i32 as _);
pub const STATUS_PKINIT_CLIENT_FAILURE: NTSTATUS = NTSTATUS(-1073740916i32 as _);
pub const STATUS_PKINIT_FAILURE: NTSTATUS = NTSTATUS(-1073741024i32 as _);
pub const STATUS_PKINIT_NAME_MISMATCH: NTSTATUS = NTSTATUS(-1073741063i32 as _);
pub const STATUS_PKU2U_CERT_FAILURE: NTSTATUS = NTSTATUS(-1073740753i32 as _);
pub const STATUS_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND: NTSTATUS = NTSTATUS(-1058340859i32 as _);
pub const STATUS_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED: NTSTATUS = NTSTATUS(-1058340860i32 as _);
pub const STATUS_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED: NTSTATUS = NTSTATUS(-1058340861i32 as _);
pub const STATUS_PLATFORM_MANIFEST_INVALID: NTSTATUS = NTSTATUS(-1058340862i32 as _);
pub const STATUS_PLATFORM_MANIFEST_NOT_ACTIVE: NTSTATUS = NTSTATUS(-1058340858i32 as _);
pub const STATUS_PLATFORM_MANIFEST_NOT_AUTHORIZED: NTSTATUS = NTSTATUS(-1058340863i32 as _);
pub const STATUS_PLATFORM_MANIFEST_NOT_SIGNED: NTSTATUS = NTSTATUS(-1058340857i32 as _);
pub const STATUS_PLUGPLAY_NO_DEVICE: NTSTATUS = NTSTATUS(-1073741218i32 as _);
pub const STATUS_PLUGPLAY_QUERY_VETOED: NTSTATUS = NTSTATUS(-2147483608i32 as _);
pub const STATUS_PNP_BAD_MPS_TABLE: NTSTATUS = NTSTATUS(-1073479627i32 as _);
pub const STATUS_PNP_DEVICE_CONFIGURATION_PENDING: NTSTATUS = NTSTATUS(-1073740651i32 as _);
pub const STATUS_PNP_DRIVER_CONFIGURATION_INCOMPLETE: NTSTATUS = NTSTATUS(-1073740653i32 as _);
pub const STATUS_PNP_DRIVER_CONFIGURATION_NOT_FOUND: NTSTATUS = NTSTATUS(-1073740654i32 as _);
pub const STATUS_PNP_DRIVER_PACKAGE_NOT_FOUND: NTSTATUS = NTSTATUS(-1073740655i32 as _);
pub const STATUS_PNP_FUNCTION_DRIVER_REQUIRED: NTSTATUS = NTSTATUS(-1073740652i32 as _);
pub const STATUS_PNP_INVALID_ID: NTSTATUS = NTSTATUS(-1073479624i32 as _);
pub const STATUS_PNP_IRQ_TRANSLATION_FAILED: NTSTATUS = NTSTATUS(-1073479625i32 as _);
pub const STATUS_PNP_NO_COMPAT_DRIVERS: NTSTATUS = NTSTATUS(-1073740656i32 as _);
pub const STATUS_PNP_REBOOT_REQUIRED: NTSTATUS = NTSTATUS(-1073741102i32 as _);
pub const STATUS_PNP_RESTART_ENUMERATION: NTSTATUS = NTSTATUS(-1073741106i32 as _);
pub const STATUS_PNP_TRANSLATION_FAILED: NTSTATUS = NTSTATUS(-1073479626i32 as _);
pub const STATUS_POLICY_OBJECT_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741158i32 as _);
pub const STATUS_POLICY_ONLY_IN_DS: NTSTATUS = NTSTATUS(-1073741157i32 as _);
pub const STATUS_PORT_ALREADY_HAS_COMPLETION_LIST: NTSTATUS = NTSTATUS(-1073740006i32 as _);
pub const STATUS_PORT_ALREADY_SET: NTSTATUS = NTSTATUS(-1073741752i32 as _);
pub const STATUS_PORT_CLOSED: NTSTATUS = NTSTATUS(-1073740032i32 as _);
pub const STATUS_PORT_CONNECTION_REFUSED: NTSTATUS = NTSTATUS(-1073741759i32 as _);
pub const STATUS_PORT_DISCONNECTED: NTSTATUS = NTSTATUS(-1073741769i32 as _);
pub const STATUS_PORT_DO_NOT_DISTURB: NTSTATUS = NTSTATUS(-1073741770i32 as _);
pub const STATUS_PORT_MESSAGE_TOO_LONG: NTSTATUS = NTSTATUS(-1073741777i32 as _);
pub const STATUS_PORT_NOT_SET: NTSTATUS = NTSTATUS(-1073740973i32 as _);
pub const STATUS_PORT_UNREACHABLE: NTSTATUS = NTSTATUS(-1073741249i32 as _);
pub const STATUS_POSSIBLE_DEADLOCK: NTSTATUS = NTSTATUS(-1073741420i32 as _);
pub const STATUS_POWER_STATE_INVALID: NTSTATUS = NTSTATUS(-1073741101i32 as _);
pub const STATUS_PREDEFINED_HANDLE: NTSTATUS = NTSTATUS(1073741846i32 as _);
pub const STATUS_PRENT4_MACHINE_ACCOUNT: NTSTATUS = NTSTATUS(-1073740969i32 as _);
pub const STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED: NTSTATUS = NTSTATUS(270i32 as _);
pub const STATUS_PRINT_CANCELLED: NTSTATUS = NTSTATUS(-1073741624i32 as _);
pub const STATUS_PRINT_QUEUE_FULL: NTSTATUS = NTSTATUS(-1073741626i32 as _);
pub const STATUS_PRIVILEGED_INSTRUCTION: NTSTATUS = NTSTATUS(-1073741674i32 as _);
pub const STATUS_PRIVILEGE_NOT_HELD: NTSTATUS = NTSTATUS(-1073741727i32 as _);
pub const STATUS_PROACTIVE_SCAN_IN_PROGRESS: NTSTATUS = NTSTATUS(-1073739761i32 as _);
pub const STATUS_PROCEDURE_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741702i32 as _);
pub const STATUS_PROCESS_CLONED: NTSTATUS = NTSTATUS(297i32 as _);
pub const STATUS_PROCESS_IN_JOB: NTSTATUS = NTSTATUS(292i32 as _);
pub const STATUS_PROCESS_IS_PROTECTED: NTSTATUS = NTSTATUS(-1073740014i32 as _);
pub const STATUS_PROCESS_IS_TERMINATING: NTSTATUS = NTSTATUS(-1073741558i32 as _);
pub const STATUS_PROCESS_NOT_IN_JOB: NTSTATUS = NTSTATUS(291i32 as _);
pub const STATUS_PROFILING_AT_LIMIT: NTSTATUS = NTSTATUS(-1073741613i32 as _);
pub const STATUS_PROFILING_NOT_STARTED: NTSTATUS = NTSTATUS(-1073741641i32 as _);
pub const STATUS_PROFILING_NOT_STOPPED: NTSTATUS = NTSTATUS(-1073741640i32 as _);
pub const STATUS_PROPSET_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741264i32 as _);
pub const STATUS_PROTOCOL_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073700845i32 as _);
pub const STATUS_PROTOCOL_UNREACHABLE: NTSTATUS = NTSTATUS(-1073741250i32 as _);
pub const STATUS_PTE_CHANGED: NTSTATUS = NTSTATUS(-1073740748i32 as _);
pub const STATUS_PURGE_FAILED: NTSTATUS = NTSTATUS(-1073740747i32 as _);
pub const STATUS_PWD_HISTORY_CONFLICT: NTSTATUS = NTSTATUS(-1073741220i32 as _);
pub const STATUS_PWD_TOO_LONG: NTSTATUS = NTSTATUS(-1073741190i32 as _);
pub const STATUS_PWD_TOO_RECENT: NTSTATUS = NTSTATUS(-1073741221i32 as _);
pub const STATUS_PWD_TOO_SHORT: NTSTATUS = NTSTATUS(-1073741222i32 as _);
pub const STATUS_QUERY_STORAGE_ERROR: NTSTATUS = NTSTATUS(-2143682559i32 as _);
pub const STATUS_QUIC_ALPN_NEG_FAILURE: NTSTATUS = NTSTATUS(-1071382521i32 as _);
pub const STATUS_QUIC_CONNECTION_IDLE: NTSTATUS = NTSTATUS(-1071382523i32 as _);
pub const STATUS_QUIC_CONNECTION_TIMEOUT: NTSTATUS = NTSTATUS(-1071382522i32 as _);
pub const STATUS_QUIC_HANDSHAKE_FAILURE: NTSTATUS = NTSTATUS(-1071382528i32 as _);
pub const STATUS_QUIC_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1071382525i32 as _);
pub const STATUS_QUIC_PROTOCOL_VIOLATION: NTSTATUS = NTSTATUS(-1071382524i32 as _);
pub const STATUS_QUIC_USER_CANCELED: NTSTATUS = NTSTATUS(-1071382526i32 as _);
pub const STATUS_QUIC_VER_NEG_FAILURE: NTSTATUS = NTSTATUS(-1071382527i32 as _);
pub const STATUS_QUOTA_ACTIVITY: NTSTATUS = NTSTATUS(-1073740662i32 as _);
pub const STATUS_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1073741756i32 as _);
pub const STATUS_QUOTA_LIST_INCONSISTENT: NTSTATUS = NTSTATUS(-1073741210i32 as _);
pub const STATUS_QUOTA_NOT_ENABLED: NTSTATUS = NTSTATUS(-1073741399i32 as _);
pub const STATUS_RANGE_LIST_CONFLICT: NTSTATUS = NTSTATUS(-1073741182i32 as _);
pub const STATUS_RANGE_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741172i32 as _);
pub const STATUS_RANGE_NOT_LOCKED: NTSTATUS = NTSTATUS(-1073741698i32 as _);
pub const STATUS_RDBSS_CONTINUE_OPERATION: NTSTATUS = NTSTATUS(-1069481982i32 as _);
pub const STATUS_RDBSS_POST_OPERATION: NTSTATUS = NTSTATUS(-1069481981i32 as _);
pub const STATUS_RDBSS_RESTART_OPERATION: NTSTATUS = NTSTATUS(-1069481983i32 as _);
pub const STATUS_RDBSS_RETRY_LOOKUP: NTSTATUS = NTSTATUS(-1069481980i32 as _);
pub const STATUS_RDP_PROTOCOL_ERROR: NTSTATUS = NTSTATUS(-1073086414i32 as _);
pub const STATUS_RECEIVE_EXPEDITED: NTSTATUS = NTSTATUS(1073741840i32 as _);
pub const STATUS_RECEIVE_PARTIAL: NTSTATUS = NTSTATUS(1073741839i32 as _);
pub const STATUS_RECEIVE_PARTIAL_EXPEDITED: NTSTATUS = NTSTATUS(1073741841i32 as _);
pub const STATUS_RECOVERABLE_BUGCHECK: NTSTATUS = NTSTATUS(-2147483596i32 as _);
pub const STATUS_RECOVERY_FAILURE: NTSTATUS = NTSTATUS(-1073741273i32 as _);
pub const STATUS_RECOVERY_NOT_NEEDED: NTSTATUS = NTSTATUS(1075380276i32 as _);
pub const STATUS_RECURSIVE_DISPATCH: NTSTATUS = NTSTATUS(-1073740028i32 as _);
pub const STATUS_REDIRECTOR_HAS_OPEN_HANDLES: NTSTATUS = NTSTATUS(-2147483613i32 as _);
pub const STATUS_REDIRECTOR_NOT_STARTED: NTSTATUS = NTSTATUS(-1073741573i32 as _);
pub const STATUS_REDIRECTOR_PAUSED: NTSTATUS = NTSTATUS(-1073741615i32 as _);
pub const STATUS_REDIRECTOR_STARTED: NTSTATUS = NTSTATUS(-1073741572i32 as _);
pub const STATUS_REGISTRY_CORRUPT: NTSTATUS = NTSTATUS(-1073741492i32 as _);
pub const STATUS_REGISTRY_HIVE_RECOVERED: NTSTATUS = NTSTATUS(-2147483606i32 as _);
pub const STATUS_REGISTRY_IO_FAILED: NTSTATUS = NTSTATUS(-1073741491i32 as _);
pub const STATUS_REGISTRY_QUOTA_LIMIT: NTSTATUS = NTSTATUS(-1073741226i32 as _);
pub const STATUS_REGISTRY_RECOVERED: NTSTATUS = NTSTATUS(1073741833i32 as _);
pub const STATUS_REG_NAT_CONSUMPTION: NTSTATUS = NTSTATUS(-1073741111i32 as _);
pub const STATUS_REINITIALIZATION_NEEDED: NTSTATUS = NTSTATUS(-1073741177i32 as _);
pub const STATUS_REMOTE_DISCONNECT: NTSTATUS = NTSTATUS(-1073741508i32 as _);
pub const STATUS_REMOTE_FILE_VERSION_MISMATCH: NTSTATUS = NTSTATUS(-1072103412i32 as _);
pub const STATUS_REMOTE_NOT_LISTENING: NTSTATUS = NTSTATUS(-1073741636i32 as _);
pub const STATUS_REMOTE_RESOURCES: NTSTATUS = NTSTATUS(-1073741507i32 as _);
pub const STATUS_REMOTE_SESSION_LIMIT: NTSTATUS = NTSTATUS(-1073741418i32 as _);
pub const STATUS_REMOTE_STORAGE_MEDIA_ERROR: NTSTATUS = NTSTATUS(-1073741154i32 as _);
pub const STATUS_REMOTE_STORAGE_NOT_ACTIVE: NTSTATUS = NTSTATUS(-1073741155i32 as _);
pub const STATUS_REPAIR_NEEDED: NTSTATUS = NTSTATUS(-1073741400i32 as _);
pub const STATUS_REPARSE: NTSTATUS = NTSTATUS(260i32 as _);
pub const STATUS_REPARSE_ATTRIBUTE_CONFLICT: NTSTATUS = NTSTATUS(-1073741134i32 as _);
pub const STATUS_REPARSE_GLOBAL: NTSTATUS = NTSTATUS(872i32 as _);
pub const STATUS_REPARSE_OBJECT: NTSTATUS = NTSTATUS(280i32 as _);
pub const STATUS_REPARSE_POINT_ENCOUNTERED: NTSTATUS = NTSTATUS(-1073740533i32 as _);
pub const STATUS_REPARSE_POINT_NOT_RESOLVED: NTSTATUS = NTSTATUS(-1073741184i32 as _);
pub const STATUS_REPLY_MESSAGE_MISMATCH: NTSTATUS = NTSTATUS(-1073741281i32 as _);
pub const STATUS_REQUEST_ABORTED: NTSTATUS = NTSTATUS(-1073741248i32 as _);
pub const STATUS_REQUEST_CANCELED: NTSTATUS = NTSTATUS(-1073740029i32 as _);
pub const STATUS_REQUEST_NOT_ACCEPTED: NTSTATUS = NTSTATUS(-1073741616i32 as _);
pub const STATUS_REQUEST_OUT_OF_SEQUENCE: NTSTATUS = NTSTATUS(-1073740758i32 as _);
pub const STATUS_REQUEST_PAUSED: NTSTATUS = NTSTATUS(-1073740711i32 as _);
pub const STATUS_RESIDENT_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073740678i32 as _);
pub const STATUS_RESOURCEMANAGER_NOT_FOUND: NTSTATUS = NTSTATUS(-1072103345i32 as _);
pub const STATUS_RESOURCEMANAGER_READ_ONLY: NTSTATUS = NTSTATUS(514i32 as _);
pub const STATUS_RESOURCE_DATA_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741687i32 as _);
pub const STATUS_RESOURCE_ENUM_USER_STOP: NTSTATUS = NTSTATUS(-1073020921i32 as _);
pub const STATUS_RESOURCE_IN_USE: NTSTATUS = NTSTATUS(-1073740024i32 as _);
pub const STATUS_RESOURCE_LANG_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741308i32 as _);
pub const STATUS_RESOURCE_NAME_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741685i32 as _);
pub const STATUS_RESOURCE_NOT_OWNED: NTSTATUS = NTSTATUS(-1073741212i32 as _);
pub const STATUS_RESOURCE_REQUIREMENTS_CHANGED: NTSTATUS = NTSTATUS(281i32 as _);
pub const STATUS_RESOURCE_TYPE_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741686i32 as _);
pub const STATUS_RESTART_BOOT_APPLICATION: NTSTATUS = NTSTATUS(-1073740717i32 as _);
pub const STATUS_RESUME_HIBERNATION: NTSTATUS = NTSTATUS(1073741867i32 as _);
pub const STATUS_RETRY: NTSTATUS = NTSTATUS(-1073741267i32 as _);
pub const STATUS_RETURN_ADDRESS_HIJACK_ATTEMPT: NTSTATUS = NTSTATUS(-2147483597i32 as _);
pub const STATUS_REVISION_MISMATCH: NTSTATUS = NTSTATUS(-1073741735i32 as _);
pub const STATUS_REVOCATION_OFFLINE_C: NTSTATUS = NTSTATUS(-1073740917i32 as _);
pub const STATUS_REVOCATION_OFFLINE_KDC: NTSTATUS = NTSTATUS(-1073740788i32 as _);
pub const STATUS_RING_NEWLY_EMPTY: NTSTATUS = NTSTATUS(531i32 as _);
pub const STATUS_RING_PREVIOUSLY_ABOVE_QUOTA: NTSTATUS = NTSTATUS(530i32 as _);
pub const STATUS_RING_PREVIOUSLY_EMPTY: NTSTATUS = NTSTATUS(528i32 as _);
pub const STATUS_RING_PREVIOUSLY_FULL: NTSTATUS = NTSTATUS(529i32 as _);
pub const STATUS_RING_SIGNAL_OPPOSITE_ENDPOINT: NTSTATUS = NTSTATUS(532i32 as _);
pub const STATUS_RKF_ACTIVE_KEY: NTSTATUS = NTSTATUS(-1069547514i32 as _);
pub const STATUS_RKF_BLOB_FULL: NTSTATUS = NTSTATUS(-1069547517i32 as _);
pub const STATUS_RKF_DUPLICATE_KEY: NTSTATUS = NTSTATUS(-1069547518i32 as _);
pub const STATUS_RKF_FILE_BLOCKED: NTSTATUS = NTSTATUS(-1069547515i32 as _);
pub const STATUS_RKF_KEY_NOT_FOUND: NTSTATUS = NTSTATUS(-1069547519i32 as _);
pub const STATUS_RKF_STORE_FULL: NTSTATUS = NTSTATUS(-1069547516i32 as _);
pub const STATUS_RM_ALREADY_STARTED: NTSTATUS = NTSTATUS(1075380277i32 as _);
pub const STATUS_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOT: NTSTATUS = NTSTATUS(-1072103331i32 as _);
pub const STATUS_RM_DISCONNECTED: NTSTATUS = NTSTATUS(-1072103374i32 as _);
pub const STATUS_RM_METADATA_CORRUPT: NTSTATUS = NTSTATUS(-1072103418i32 as _);
pub const STATUS_RM_NOT_ACTIVE: NTSTATUS = NTSTATUS(-1072103419i32 as _);
pub const STATUS_ROLLBACK_TIMER_EXPIRED: NTSTATUS = NTSTATUS(-1072103364i32 as _);
pub const STATUS_RTPM_CONTEXT_COMPLETE: NTSTATUS = NTSTATUS(2699265i32 as _);
pub const STATUS_RTPM_CONTEXT_CONTINUE: NTSTATUS = NTSTATUS(2699264i32 as _);
pub const STATUS_RTPM_INVALID_CONTEXT: NTSTATUS = NTSTATUS(-1071042556i32 as _);
pub const STATUS_RTPM_NO_RESULT: NTSTATUS = NTSTATUS(-1071042558i32 as _);
pub const STATUS_RTPM_PCR_READ_INCOMPLETE: NTSTATUS = NTSTATUS(-1071042557i32 as _);
pub const STATUS_RTPM_UNSUPPORTED_CMD: NTSTATUS = NTSTATUS(-1071042555i32 as _);
pub const STATUS_RUNLEVEL_SWITCH_AGENT_TIMEOUT: NTSTATUS = NTSTATUS(-1073700539i32 as _);
pub const STATUS_RUNLEVEL_SWITCH_IN_PROGRESS: NTSTATUS = NTSTATUS(-1073700538i32 as _);
pub const STATUS_RUNLEVEL_SWITCH_TIMEOUT: NTSTATUS = NTSTATUS(-1073700541i32 as _);
pub const STATUS_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED: NTSTATUS = NTSTATUS(-1073740633i32 as _);
pub const STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET: NTSTATUS = NTSTATUS(-1073740632i32 as _);
pub const STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE: NTSTATUS = NTSTATUS(-1073740631i32 as _);
pub const STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER: NTSTATUS = NTSTATUS(-1073740630i32 as _);
pub const STATUS_RXACT_COMMITTED: NTSTATUS = NTSTATUS(266i32 as _);
pub const STATUS_RXACT_COMMIT_FAILURE: NTSTATUS = NTSTATUS(-1073741539i32 as _);
pub const STATUS_RXACT_COMMIT_NECESSARY: NTSTATUS = NTSTATUS(-2147483624i32 as _);
pub const STATUS_RXACT_INVALID_STATE: NTSTATUS = NTSTATUS(-1073741540i32 as _);
pub const STATUS_RXACT_STATE_CREATED: NTSTATUS = NTSTATUS(1073741828i32 as _);
pub const STATUS_SAM_INIT_FAILURE: NTSTATUS = NTSTATUS(-1073741085i32 as _);
pub const STATUS_SAM_NEED_BOOTKEY_FLOPPY: NTSTATUS = NTSTATUS(-1073741088i32 as _);
pub const STATUS_SAM_NEED_BOOTKEY_PASSWORD: NTSTATUS = NTSTATUS(-1073741089i32 as _);
pub const STATUS_SCRUB_DATA_DISABLED: NTSTATUS = NTSTATUS(-1073740680i32 as _);
pub const STATUS_SECCORE_INVALID_COMMAND: NTSTATUS = NTSTATUS(-1058537472i32 as _);
pub const STATUS_SECONDARY_IC_PROVIDER_NOT_REGISTERED: NTSTATUS = NTSTATUS(-1073700575i32 as _);
pub const STATUS_SECRET_TOO_LONG: NTSTATUS = NTSTATUS(-1073741481i32 as _);
pub const STATUS_SECTION_DIRECT_MAP_ONLY: NTSTATUS = NTSTATUS(-1073739503i32 as _);
pub const STATUS_SECTION_NOT_EXTENDED: NTSTATUS = NTSTATUS(-1073741689i32 as _);
pub const STATUS_SECTION_NOT_IMAGE: NTSTATUS = NTSTATUS(-1073741751i32 as _);
pub const STATUS_SECTION_PROTECTION: NTSTATUS = NTSTATUS(-1073741746i32 as _);
pub const STATUS_SECTION_TOO_BIG: NTSTATUS = NTSTATUS(-1073741760i32 as _);
pub const STATUS_SECUREBOOT_FILE_REPLACED: NTSTATUS = NTSTATUS(-1069350905i32 as _);
pub const STATUS_SECUREBOOT_INVALID_POLICY: NTSTATUS = NTSTATUS(-1069350909i32 as _);
pub const STATUS_SECUREBOOT_NOT_BASE_POLICY: NTSTATUS = NTSTATUS(-1069350897i32 as _);
pub const STATUS_SECUREBOOT_NOT_ENABLED: NTSTATUS = NTSTATUS(-2143092730i32 as _);
pub const STATUS_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY: NTSTATUS = NTSTATUS(-1069350896i32 as _);
pub const STATUS_SECUREBOOT_PLATFORM_ID_MISMATCH: NTSTATUS = NTSTATUS(-1069350901i32 as _);
pub const STATUS_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION: NTSTATUS = NTSTATUS(-1069350902i32 as _);
pub const STATUS_SECUREBOOT_POLICY_NOT_AUTHORIZED: NTSTATUS = NTSTATUS(-1069350904i32 as _);
pub const STATUS_SECUREBOOT_POLICY_NOT_SIGNED: NTSTATUS = NTSTATUS(-1069350907i32 as _);
pub const STATUS_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND: NTSTATUS = NTSTATUS(-1069350908i32 as _);
pub const STATUS_SECUREBOOT_POLICY_ROLLBACK_DETECTED: NTSTATUS = NTSTATUS(-1069350900i32 as _);
pub const STATUS_SECUREBOOT_POLICY_UNKNOWN: NTSTATUS = NTSTATUS(-1069350903i32 as _);
pub const STATUS_SECUREBOOT_POLICY_UPGRADE_MISMATCH: NTSTATUS = NTSTATUS(-1069350899i32 as _);
pub const STATUS_SECUREBOOT_POLICY_VIOLATION: NTSTATUS = NTSTATUS(-1069350910i32 as _);
pub const STATUS_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING: NTSTATUS = NTSTATUS(-1069350898i32 as _);
pub const STATUS_SECUREBOOT_ROLLBACK_DETECTED: NTSTATUS = NTSTATUS(-1069350911i32 as _);
pub const STATUS_SECURITY_STREAM_IS_INCONSISTENT: NTSTATUS = NTSTATUS(-1073741408i32 as _);
pub const STATUS_SEGMENT_NOTIFICATION: NTSTATUS = NTSTATUS(1073741829i32 as _);
pub const STATUS_SEMAPHORE_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1073741753i32 as _);
pub const STATUS_SERIAL_COUNTER_TIMEOUT: NTSTATUS = NTSTATUS(1073741836i32 as _);
pub const STATUS_SERIAL_MORE_WRITES: NTSTATUS = NTSTATUS(1073741832i32 as _);
pub const STATUS_SERIAL_NO_DEVICE_INITED: NTSTATUS = NTSTATUS(-1073741488i32 as _);
pub const STATUS_SERVER_DISABLED: NTSTATUS = NTSTATUS(-1073741696i32 as _);
pub const STATUS_SERVER_HAS_OPEN_HANDLES: NTSTATUS = NTSTATUS(-2147483612i32 as _);
pub const STATUS_SERVER_NOT_DISABLED: NTSTATUS = NTSTATUS(-1073741695i32 as _);
pub const STATUS_SERVER_SHUTDOWN_IN_PROGRESS: NTSTATUS = NTSTATUS(-1073741057i32 as _);
pub const STATUS_SERVER_SID_MISMATCH: NTSTATUS = NTSTATUS(-1073741152i32 as _);
pub const STATUS_SERVER_TRANSPORT_CONFLICT: NTSTATUS = NTSTATUS(-1073741388i32 as _);
pub const STATUS_SERVER_UNAVAILABLE: NTSTATUS = NTSTATUS(-1073740698i32 as _);
pub const STATUS_SERVICES_FAILED_AUTOSTART: NTSTATUS = NTSTATUS(1073783108i32 as _);
pub const STATUS_SERVICE_NOTIFICATION: NTSTATUS = NTSTATUS(1073741848i32 as _);
pub const STATUS_SESSION_KEY_TOO_SHORT: NTSTATUS = NTSTATUS(-1073740521i32 as _);
pub const STATUS_SETMARK_DETECTED: NTSTATUS = NTSTATUS(-2147483615i32 as _);
pub const STATUS_SET_CONTEXT_DENIED: NTSTATUS = NTSTATUS(-1073740278i32 as _);
pub const STATUS_SEVERITY_COERROR: u32 = 2u32;
pub const STATUS_SEVERITY_COFAIL: u32 = 3u32;
pub const STATUS_SHARED_IRQ_BUSY: NTSTATUS = NTSTATUS(-1073741460i32 as _);
pub const STATUS_SHARED_POLICY: NTSTATUS = NTSTATUS(-1073741159i32 as _);
pub const STATUS_SHARE_UNAVAILABLE: NTSTATUS = NTSTATUS(-1073740672i32 as _);
pub const STATUS_SHARING_PAUSED: NTSTATUS = NTSTATUS(-1073741617i32 as _);
pub const STATUS_SHARING_VIOLATION: NTSTATUS = NTSTATUS(-1073741757i32 as _);
pub const STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME: NTSTATUS = NTSTATUS(-1073741409i32 as _);
pub const STATUS_SHUTDOWN_IN_PROGRESS: NTSTATUS = NTSTATUS(-1073741058i32 as _);
pub const STATUS_SINGLE_STEP: NTSTATUS = NTSTATUS(-2147483644i32 as _);
pub const STATUS_SMARTCARD_CARD_BLOCKED: NTSTATUS = NTSTATUS(-1073740927i32 as _);
pub const STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED: NTSTATUS = NTSTATUS(-1073740926i32 as _);
pub const STATUS_SMARTCARD_CERT_EXPIRED: NTSTATUS = NTSTATUS(-1073740915i32 as _);
pub const STATUS_SMARTCARD_CERT_REVOKED: NTSTATUS = NTSTATUS(-1073740919i32 as _);
pub const STATUS_SMARTCARD_IO_ERROR: NTSTATUS = NTSTATUS(-1073740921i32 as _);
pub const STATUS_SMARTCARD_LOGON_REQUIRED: NTSTATUS = NTSTATUS(-1073741062i32 as _);
pub const STATUS_SMARTCARD_NO_CARD: NTSTATUS = NTSTATUS(-1073740925i32 as _);
pub const STATUS_SMARTCARD_NO_CERTIFICATE: NTSTATUS = NTSTATUS(-1073740923i32 as _);
pub const STATUS_SMARTCARD_NO_KEYSET: NTSTATUS = NTSTATUS(-1073740922i32 as _);
pub const STATUS_SMARTCARD_NO_KEY_CONTAINER: NTSTATUS = NTSTATUS(-1073740924i32 as _);
pub const STATUS_SMARTCARD_SILENT_CONTEXT: NTSTATUS = NTSTATUS(-1073740913i32 as _);
pub const STATUS_SMARTCARD_SUBSYSTEM_FAILURE: NTSTATUS = NTSTATUS(-1073741023i32 as _);
pub const STATUS_SMARTCARD_WRONG_PIN: NTSTATUS = NTSTATUS(-1073740928i32 as _);
pub const STATUS_SMB1_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1073740525i32 as _);
pub const STATUS_SMB_BAD_CLUSTER_DIALECT: NTSTATUS = NTSTATUS(-1067646975i32 as _);
pub const STATUS_SMB_GUEST_LOGON_BLOCKED: NTSTATUS = NTSTATUS(-1067646974i32 as _);
pub const STATUS_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP: NTSTATUS = NTSTATUS(-1067646976i32 as _);
pub const STATUS_SMB_NO_SIGNING_ALGORITHM_OVERLAP: NTSTATUS = NTSTATUS(-1067646973i32 as _);
pub const STATUS_SMI_PRIMITIVE_INSTALLER_FAILED: NTSTATUS = NTSTATUS(-1072365531i32 as _);
pub const STATUS_SMR_GARBAGE_COLLECTION_REQUIRED: NTSTATUS = NTSTATUS(-1073740524i32 as _);
pub const STATUS_SOME_NOT_MAPPED: NTSTATUS = NTSTATUS(263i32 as _);
pub const STATUS_SOURCE_ELEMENT_EMPTY: NTSTATUS = NTSTATUS(-1073741181i32 as _);
pub const STATUS_SPACES_ALLOCATION_SIZE_INVALID: NTSTATUS = NTSTATUS(-1058602994i32 as _);
pub const STATUS_SPACES_CACHE_FULL: NTSTATUS = NTSTATUS(-1058602970i32 as _);
pub const STATUS_SPACES_COMPLETE: NTSTATUS = NTSTATUS(15138818i32 as _);
pub const STATUS_SPACES_CORRUPT_METADATA: NTSTATUS = NTSTATUS(-1058602986i32 as _);
pub const STATUS_SPACES_DRIVE_LOST_DATA: NTSTATUS = NTSTATUS(-1058602979i32 as _);
pub const STATUS_SPACES_DRIVE_NOT_READY: NTSTATUS = NTSTATUS(-1058602981i32 as _);
pub const STATUS_SPACES_DRIVE_OPERATIONAL_STATE_INVALID: NTSTATUS = NTSTATUS(-1058602990i32 as _);
pub const STATUS_SPACES_DRIVE_REDUNDANCY_INVALID: NTSTATUS = NTSTATUS(-1058603002i32 as _);
pub const STATUS_SPACES_DRIVE_SECTOR_SIZE_INVALID: NTSTATUS = NTSTATUS(-1058603004i32 as _);
pub const STATUS_SPACES_DRIVE_SPLIT: NTSTATUS = NTSTATUS(-1058602980i32 as _);
pub const STATUS_SPACES_DRT_FULL: NTSTATUS = NTSTATUS(-1058602985i32 as _);
pub const STATUS_SPACES_ENCLOSURE_AWARE_INVALID: NTSTATUS = NTSTATUS(-1058602993i32 as _);
pub const STATUS_SPACES_ENTRY_INCOMPLETE: NTSTATUS = NTSTATUS(-1058602978i32 as _);
pub const STATUS_SPACES_ENTRY_INVALID: NTSTATUS = NTSTATUS(-1058602977i32 as _);
pub const STATUS_SPACES_EXTENDED_ERROR: NTSTATUS = NTSTATUS(-1058602996i32 as _);
pub const STATUS_SPACES_FAULT_DOMAIN_TYPE_INVALID: NTSTATUS = NTSTATUS(-1058603007i32 as _);
pub const STATUS_SPACES_FLUSH_METADATA: NTSTATUS = NTSTATUS(-1058602971i32 as _);
pub const STATUS_SPACES_INCONSISTENCY: NTSTATUS = NTSTATUS(-1058602984i32 as _);
pub const STATUS_SPACES_INTERLEAVE_LENGTH_INVALID: NTSTATUS = NTSTATUS(-1058602999i32 as _);
pub const STATUS_SPACES_LOG_NOT_READY: NTSTATUS = NTSTATUS(-1058602983i32 as _);
pub const STATUS_SPACES_MAP_REQUIRED: NTSTATUS = NTSTATUS(-1058602988i32 as _);
pub const STATUS_SPACES_MARK_DIRTY: NTSTATUS = NTSTATUS(-1058602976i32 as _);
pub const STATUS_SPACES_NOT_ENOUGH_DRIVES: NTSTATUS = NTSTATUS(-1058602997i32 as _);
pub const STATUS_SPACES_NO_REDUNDANCY: NTSTATUS = NTSTATUS(-1058602982i32 as _);
pub const STATUS_SPACES_NUMBER_OF_COLUMNS_INVALID: NTSTATUS = NTSTATUS(-1058602998i32 as _);
pub const STATUS_SPACES_NUMBER_OF_DATA_COPIES_INVALID: NTSTATUS = NTSTATUS(-1058603001i32 as _);
pub const STATUS_SPACES_NUMBER_OF_GROUPS_INVALID: NTSTATUS = NTSTATUS(-1058602991i32 as _);
pub const STATUS_SPACES_PAUSE: NTSTATUS = NTSTATUS(15138817i32 as _);
pub const STATUS_SPACES_PD_INVALID_DATA: NTSTATUS = NTSTATUS(-1058602972i32 as _);
pub const STATUS_SPACES_PD_LENGTH_MISMATCH: NTSTATUS = NTSTATUS(-1058602974i32 as _);
pub const STATUS_SPACES_PD_NOT_FOUND: NTSTATUS = NTSTATUS(-1058602975i32 as _);
pub const STATUS_SPACES_PD_UNSUPPORTED_VERSION: NTSTATUS = NTSTATUS(-1058602973i32 as _);
pub const STATUS_SPACES_PROVISIONING_TYPE_INVALID: NTSTATUS = NTSTATUS(-1058602995i32 as _);
pub const STATUS_SPACES_REDIRECT: NTSTATUS = NTSTATUS(15138819i32 as _);
pub const STATUS_SPACES_REPAIRED: NTSTATUS = NTSTATUS(15138816i32 as _);
pub const STATUS_SPACES_RESILIENCY_TYPE_INVALID: NTSTATUS = NTSTATUS(-1058603005i32 as _);
pub const STATUS_SPACES_UNSUPPORTED_VERSION: NTSTATUS = NTSTATUS(-1058602987i32 as _);
pub const STATUS_SPACES_UPDATE_COLUMN_STATE: NTSTATUS = NTSTATUS(-1058602989i32 as _);
pub const STATUS_SPACES_WRITE_CACHE_SIZE_INVALID: NTSTATUS = NTSTATUS(-1058602992i32 as _);
pub const STATUS_SPARSE_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073740604i32 as _);
pub const STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION: NTSTATUS = NTSTATUS(-1072103351i32 as _);
pub const STATUS_SPECIAL_ACCOUNT: NTSTATUS = NTSTATUS(-1073741532i32 as _);
pub const STATUS_SPECIAL_GROUP: NTSTATUS = NTSTATUS(-1073741531i32 as _);
pub const STATUS_SPECIAL_USER: NTSTATUS = NTSTATUS(-1073741530i32 as _);
pub const STATUS_STACK_BUFFER_OVERRUN: NTSTATUS = NTSTATUS(-1073740791i32 as _);
pub const STATUS_STACK_OVERFLOW: NTSTATUS = NTSTATUS(-1073741571i32 as _);
pub const STATUS_STACK_OVERFLOW_READ: NTSTATUS = NTSTATUS(-1073741272i32 as _);
pub const STATUS_STOPPED_ON_SYMLINK: NTSTATUS = NTSTATUS(-2147483603i32 as _);
pub const STATUS_STORAGE_LOST_DATA_PERSISTENCE: NTSTATUS = NTSTATUS(-1073740642i32 as _);
pub const STATUS_STORAGE_RESERVE_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1073740625i32 as _);
pub const STATUS_STORAGE_RESERVE_DOES_NOT_EXIST: NTSTATUS = NTSTATUS(-1073740626i32 as _);
pub const STATUS_STORAGE_RESERVE_ID_INVALID: NTSTATUS = NTSTATUS(-1073740627i32 as _);
pub const STATUS_STORAGE_RESERVE_NOT_EMPTY: NTSTATUS = NTSTATUS(-1073740624i32 as _);
pub const STATUS_STORAGE_STACK_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1073740607i32 as _);
pub const STATUS_STORAGE_TOPOLOGY_ID_MISMATCH: NTSTATUS = NTSTATUS(-1073740666i32 as _);
pub const STATUS_STOWED_EXCEPTION: NTSTATUS = NTSTATUS(-1073741189i32 as _);
pub const STATUS_STREAM_MINIVERSION_NOT_FOUND: NTSTATUS = NTSTATUS(-1072103390i32 as _);
pub const STATUS_STREAM_MINIVERSION_NOT_VALID: NTSTATUS = NTSTATUS(-1072103389i32 as _);
pub const STATUS_STRICT_CFG_VIOLATION: NTSTATUS = NTSTATUS(-1073740282i32 as _);
pub const STATUS_STRONG_CRYPTO_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073741066i32 as _);
pub const STATUS_SUCCESS: NTSTATUS = NTSTATUS(0i32 as _);
pub const STATUS_SUSPEND_COUNT_EXCEEDED: NTSTATUS = NTSTATUS(-1073741750i32 as _);
pub const STATUS_SVHDX_ERROR_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1067647232i32 as _);
pub const STATUS_SVHDX_ERROR_STORED: NTSTATUS = NTSTATUS(-1067712512i32 as _);
pub const STATUS_SVHDX_NO_INITIATOR: NTSTATUS = NTSTATUS(-1067647221i32 as _);
pub const STATUS_SVHDX_RESERVATION_CONFLICT: NTSTATUS = NTSTATUS(-1067647225i32 as _);
pub const STATUS_SVHDX_UNIT_ATTENTION_AVAILABLE: NTSTATUS = NTSTATUS(-1067647231i32 as _);
pub const STATUS_SVHDX_UNIT_ATTENTION_CAPACITY_DATA_CHANGED: NTSTATUS = NTSTATUS(-1067647230i32 as _);
pub const STATUS_SVHDX_UNIT_ATTENTION_OPERATING_DEFINITION_CHANGED: NTSTATUS = NTSTATUS(-1067647226i32 as _);
pub const STATUS_SVHDX_UNIT_ATTENTION_REGISTRATIONS_PREEMPTED: NTSTATUS = NTSTATUS(-1067647227i32 as _);
pub const STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_PREEMPTED: NTSTATUS = NTSTATUS(-1067647229i32 as _);
pub const STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_RELEASED: NTSTATUS = NTSTATUS(-1067647228i32 as _);
pub const STATUS_SVHDX_VERSION_MISMATCH: NTSTATUS = NTSTATUS(-1067647223i32 as _);
pub const STATUS_SVHDX_WRONG_FILE_TYPE: NTSTATUS = NTSTATUS(-1067647224i32 as _);
pub const STATUS_SXS_ACTIVATION_CONTEXT_DISABLED: NTSTATUS = NTSTATUS(-1072365561i32 as _);
pub const STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT: NTSTATUS = NTSTATUS(-1072365538i32 as _);
pub const STATUS_SXS_ASSEMBLY_MISSING: NTSTATUS = NTSTATUS(-1072365556i32 as _);
pub const STATUS_SXS_ASSEMBLY_NOT_FOUND: NTSTATUS = NTSTATUS(-1072365564i32 as _);
pub const STATUS_SXS_CANT_GEN_ACTCTX: NTSTATUS = NTSTATUS(-1072365566i32 as _);
pub const STATUS_SXS_COMPONENT_STORE_CORRUPT: NTSTATUS = NTSTATUS(-1072365542i32 as _);
pub const STATUS_SXS_CORRUPTION: NTSTATUS = NTSTATUS(-1072365547i32 as _);
pub const STATUS_SXS_CORRUPT_ACTIVATION_STACK: NTSTATUS = NTSTATUS(-1072365548i32 as _);
pub const STATUS_SXS_EARLY_DEACTIVATION: NTSTATUS = NTSTATUS(-1072365553i32 as _);
pub const STATUS_SXS_FILE_HASH_MISMATCH: NTSTATUS = NTSTATUS(-1072365541i32 as _);
pub const STATUS_SXS_FILE_HASH_MISSING: NTSTATUS = NTSTATUS(-1072365529i32 as _);
pub const STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY: NTSTATUS = NTSTATUS(-1072365537i32 as _);
pub const STATUS_SXS_IDENTITIES_DIFFERENT: NTSTATUS = NTSTATUS(-1072365539i32 as _);
pub const STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE: NTSTATUS = NTSTATUS(-1072365544i32 as _);
pub const STATUS_SXS_IDENTITY_PARSE_ERROR: NTSTATUS = NTSTATUS(-1072365543i32 as _);
pub const STATUS_SXS_INVALID_ACTCTXDATA_FORMAT: NTSTATUS = NTSTATUS(-1072365565i32 as _);
pub const STATUS_SXS_INVALID_DEACTIVATION: NTSTATUS = NTSTATUS(-1072365552i32 as _);
pub const STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME: NTSTATUS = NTSTATUS(-1072365545i32 as _);
pub const STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE: NTSTATUS = NTSTATUS(-1072365546i32 as _);
pub const STATUS_SXS_KEY_NOT_FOUND: NTSTATUS = NTSTATUS(-1072365560i32 as _);
pub const STATUS_SXS_MANIFEST_FORMAT_ERROR: NTSTATUS = NTSTATUS(-1072365563i32 as _);
pub const STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT: NTSTATUS = NTSTATUS(-1072365540i32 as _);
pub const STATUS_SXS_MANIFEST_PARSE_ERROR: NTSTATUS = NTSTATUS(-1072365562i32 as _);
pub const STATUS_SXS_MANIFEST_TOO_BIG: NTSTATUS = NTSTATUS(-1072365534i32 as _);
pub const STATUS_SXS_MULTIPLE_DEACTIVATION: NTSTATUS = NTSTATUS(-1072365551i32 as _);
pub const STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET: NTSTATUS = NTSTATUS(-1072365554i32 as _);
pub const STATUS_SXS_PROCESS_TERMINATION_REQUESTED: NTSTATUS = NTSTATUS(-1072365549i32 as _);
pub const STATUS_SXS_RELEASE_ACTIVATION_CONTEXT: NTSTATUS = NTSTATUS(1075118093i32 as _);
pub const STATUS_SXS_SECTION_NOT_FOUND: NTSTATUS = NTSTATUS(-1072365567i32 as _);
pub const STATUS_SXS_SETTING_NOT_REGISTERED: NTSTATUS = NTSTATUS(-1072365533i32 as _);
pub const STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY: NTSTATUS = NTSTATUS(-1072365550i32 as _);
pub const STATUS_SXS_THREAD_QUERIES_DISABLED: NTSTATUS = NTSTATUS(-1072365557i32 as _);
pub const STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE: NTSTATUS = NTSTATUS(-1072365532i32 as _);
pub const STATUS_SXS_VERSION_CONFLICT: NTSTATUS = NTSTATUS(-1072365559i32 as _);
pub const STATUS_SXS_WRONG_SECTION_TYPE: NTSTATUS = NTSTATUS(-1072365558i32 as _);
pub const STATUS_SYMLINK_CLASS_DISABLED: NTSTATUS = NTSTATUS(-1073740011i32 as _);
pub const STATUS_SYNCHRONIZATION_REQUIRED: NTSTATUS = NTSTATUS(-1073741516i32 as _);
pub const STATUS_SYSTEM_DEVICE_NOT_FOUND: NTSTATUS = NTSTATUS(-1073740718i32 as _);
pub const STATUS_SYSTEM_HIVE_TOO_LARGE: NTSTATUS = NTSTATUS(-1073740946i32 as _);
pub const STATUS_SYSTEM_IMAGE_BAD_SIGNATURE: NTSTATUS = NTSTATUS(-1073741103i32 as _);
pub const STATUS_SYSTEM_INTEGRITY_INVALID_POLICY: NTSTATUS = NTSTATUS(-1058471933i32 as _);
pub const STATUS_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED: NTSTATUS = NTSTATUS(-1058471932i32 as _);
pub const STATUS_SYSTEM_INTEGRITY_POLICY_VIOLATION: NTSTATUS = NTSTATUS(-1058471934i32 as _);
pub const STATUS_SYSTEM_INTEGRITY_REPUTATION_DANGEROUS_EXT: NTSTATUS = NTSTATUS(-1058471927i32 as _);
pub const STATUS_SYSTEM_INTEGRITY_REPUTATION_MALICIOUS: NTSTATUS = NTSTATUS(-1058471929i32 as _);
pub const STATUS_SYSTEM_INTEGRITY_REPUTATION_OFFLINE: NTSTATUS = NTSTATUS(-1058471926i32 as _);
pub const STATUS_SYSTEM_INTEGRITY_REPUTATION_PUA: NTSTATUS = NTSTATUS(-1058471928i32 as _);
pub const STATUS_SYSTEM_INTEGRITY_ROLLBACK_DETECTED: NTSTATUS = NTSTATUS(-1058471935i32 as _);
pub const STATUS_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED: NTSTATUS = NTSTATUS(-1058471930i32 as _);
pub const STATUS_SYSTEM_INTEGRITY_TOO_MANY_POLICIES: NTSTATUS = NTSTATUS(-1058471931i32 as _);
pub const STATUS_SYSTEM_NEEDS_REMEDIATION: NTSTATUS = NTSTATUS(-1073740674i32 as _);
pub const STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION: NTSTATUS = NTSTATUS(1073741873i32 as _);
pub const STATUS_SYSTEM_POWERSTATE_TRANSITION: NTSTATUS = NTSTATUS(1073741871i32 as _);
pub const STATUS_SYSTEM_PROCESS_TERMINATED: NTSTATUS = NTSTATUS(-1073741286i32 as _);
pub const STATUS_SYSTEM_SHUTDOWN: NTSTATUS = NTSTATUS(-1073741077i32 as _);
pub const STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED: NTSTATUS = NTSTATUS(-1073740018i32 as _);
pub const STATUS_THREADPOOL_HANDLE_EXCEPTION: NTSTATUS = NTSTATUS(-1073740022i32 as _);
pub const STATUS_THREADPOOL_RELEASED_DURING_OPERATION: NTSTATUS = NTSTATUS(-1073740017i32 as _);
pub const STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED: NTSTATUS = NTSTATUS(-1073740019i32 as _);
pub const STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED: NTSTATUS = NTSTATUS(-1073740020i32 as _);
pub const STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED: NTSTATUS = NTSTATUS(-1073740021i32 as _);
pub const STATUS_THREAD_ALREADY_IN_SESSION: NTSTATUS = NTSTATUS(-1073740714i32 as _);
pub const STATUS_THREAD_ALREADY_IN_TASK: NTSTATUS = NTSTATUS(-1073740542i32 as _);
pub const STATUS_THREAD_IS_TERMINATING: NTSTATUS = NTSTATUS(-1073741749i32 as _);
pub const STATUS_THREAD_NOT_IN_PROCESS: NTSTATUS = NTSTATUS(-1073741526i32 as _);
pub const STATUS_THREAD_NOT_IN_SESSION: NTSTATUS = NTSTATUS(-1073740713i32 as _);
pub const STATUS_THREAD_NOT_RUNNING: NTSTATUS = NTSTATUS(-1073740522i32 as _);
pub const STATUS_THREAD_WAS_SUSPENDED: NTSTATUS = NTSTATUS(1073741825i32 as _);
pub const STATUS_TIMEOUT: NTSTATUS = NTSTATUS(258i32 as _);
pub const STATUS_TIMER_NOT_CANCELED: NTSTATUS = NTSTATUS(-1073741812i32 as _);
pub const STATUS_TIMER_RESOLUTION_NOT_SET: NTSTATUS = NTSTATUS(-1073741243i32 as _);
pub const STATUS_TIMER_RESUME_IGNORED: NTSTATUS = NTSTATUS(1073741861i32 as _);
pub const STATUS_TIME_DIFFERENCE_AT_DC: NTSTATUS = NTSTATUS(-1073741517i32 as _);
pub const STATUS_TM_IDENTITY_MISMATCH: NTSTATUS = NTSTATUS(-1072103350i32 as _);
pub const STATUS_TM_INITIALIZATION_FAILED: NTSTATUS = NTSTATUS(-1072103420i32 as _);
pub const STATUS_TM_VOLATILE: NTSTATUS = NTSTATUS(-1072103365i32 as _);
pub const STATUS_TOKEN_ALREADY_IN_USE: NTSTATUS = NTSTATUS(-1073741525i32 as _);
pub const STATUS_TOO_LATE: NTSTATUS = NTSTATUS(-1073741431i32 as _);
pub const STATUS_TOO_MANY_ADDRESSES: NTSTATUS = NTSTATUS(-1073741303i32 as _);
pub const STATUS_TOO_MANY_COMMANDS: NTSTATUS = NTSTATUS(-1073741631i32 as _);
pub const STATUS_TOO_MANY_CONTEXT_IDS: NTSTATUS = NTSTATUS(-1073741478i32 as _);
pub const STATUS_TOO_MANY_GUIDS_REQUESTED: NTSTATUS = NTSTATUS(-1073741694i32 as _);
pub const STATUS_TOO_MANY_LINKS: NTSTATUS = NTSTATUS(-1073741211i32 as _);
pub const STATUS_TOO_MANY_LUIDS_REQUESTED: NTSTATUS = NTSTATUS(-1073741708i32 as _);
pub const STATUS_TOO_MANY_NAMES: NTSTATUS = NTSTATUS(-1073741619i32 as _);
pub const STATUS_TOO_MANY_NODES: NTSTATUS = NTSTATUS(-1073741298i32 as _);
pub const STATUS_TOO_MANY_OPENED_FILES: NTSTATUS = NTSTATUS(-1073741537i32 as _);
pub const STATUS_TOO_MANY_PAGING_FILES: NTSTATUS = NTSTATUS(-1073741673i32 as _);
pub const STATUS_TOO_MANY_PRINCIPALS: NTSTATUS = NTSTATUS(-1073741065i32 as _);
pub const STATUS_TOO_MANY_SECRETS: NTSTATUS = NTSTATUS(-1073741482i32 as _);
pub const STATUS_TOO_MANY_SEGMENT_DESCRIPTORS: NTSTATUS = NTSTATUS(-1073740685i32 as _);
pub const STATUS_TOO_MANY_SESSIONS: NTSTATUS = NTSTATUS(-1073741618i32 as _);
pub const STATUS_TOO_MANY_SIDS: NTSTATUS = NTSTATUS(-1073741442i32 as _);
pub const STATUS_TOO_MANY_THREADS: NTSTATUS = NTSTATUS(-1073741527i32 as _);
pub const STATUS_TPM_20_E_ASYMMETRIC: NTSTATUS = NTSTATUS(-1071054719i32 as _);
pub const STATUS_TPM_20_E_ATTRIBUTES: NTSTATUS = NTSTATUS(-1071054718i32 as _);
pub const STATUS_TPM_20_E_AUTHSIZE: NTSTATUS = NTSTATUS(-1071054524i32 as _);
pub const STATUS_TPM_20_E_AUTH_CONTEXT: NTSTATUS = NTSTATUS(-1071054523i32 as _);
pub const STATUS_TPM_20_E_AUTH_FAIL: NTSTATUS = NTSTATUS(-1071054706i32 as _);
pub const STATUS_TPM_20_E_AUTH_MISSING: NTSTATUS = NTSTATUS(-1071054555i32 as _);
pub const STATUS_TPM_20_E_AUTH_TYPE: NTSTATUS = NTSTATUS(-1071054556i32 as _);
pub const STATUS_TPM_20_E_AUTH_UNAVAILABLE: NTSTATUS = NTSTATUS(-1071054545i32 as _);
pub const STATUS_TPM_20_E_BAD_AUTH: NTSTATUS = NTSTATUS(-1071054686i32 as _);
pub const STATUS_TPM_20_E_BAD_CONTEXT: NTSTATUS = NTSTATUS(-1071054512i32 as _);
pub const STATUS_TPM_20_E_BINDING: NTSTATUS = NTSTATUS(-1071054683i32 as _);
pub const STATUS_TPM_20_E_COMMAND_CODE: NTSTATUS = NTSTATUS(-1071054525i32 as _);
pub const STATUS_TPM_20_E_COMMAND_SIZE: NTSTATUS = NTSTATUS(-1071054526i32 as _);
pub const STATUS_TPM_20_E_CPHASH: NTSTATUS = NTSTATUS(-1071054511i32 as _);
pub const STATUS_TPM_20_E_CURVE: NTSTATUS = NTSTATUS(-1071054682i32 as _);
pub const STATUS_TPM_20_E_DISABLED: NTSTATUS = NTSTATUS(-1071054560i32 as _);
pub const STATUS_TPM_20_E_ECC_CURVE: NTSTATUS = NTSTATUS(-1071054557i32 as _);
pub const STATUS_TPM_20_E_ECC_POINT: NTSTATUS = NTSTATUS(-1071054681i32 as _);
pub const STATUS_TPM_20_E_EXCLUSIVE: NTSTATUS = NTSTATUS(-1071054559i32 as _);
pub const STATUS_TPM_20_E_EXPIRED: NTSTATUS = NTSTATUS(-1071054685i32 as _);
pub const STATUS_TPM_20_E_FAILURE: NTSTATUS = NTSTATUS(-1071054591i32 as _);
pub const STATUS_TPM_20_E_HANDLE: NTSTATUS = NTSTATUS(-1071054709i32 as _);
pub const STATUS_TPM_20_E_HASH: NTSTATUS = NTSTATUS(-1071054717i32 as _);
pub const STATUS_TPM_20_E_HIERARCHY: NTSTATUS = NTSTATUS(-1071054715i32 as _);
pub const STATUS_TPM_20_E_HMAC: NTSTATUS = NTSTATUS(-1071054567i32 as _);
pub const STATUS_TPM_20_E_INITIALIZE: NTSTATUS = NTSTATUS(-1071054592i32 as _);
pub const STATUS_TPM_20_E_INSUFFICIENT: NTSTATUS = NTSTATUS(-1071054694i32 as _);
pub const STATUS_TPM_20_E_INTEGRITY: NTSTATUS = NTSTATUS(-1071054689i32 as _);
pub const STATUS_TPM_20_E_KDF: NTSTATUS = NTSTATUS(-1071054708i32 as _);
pub const STATUS_TPM_20_E_KEY: NTSTATUS = NTSTATUS(-1071054692i32 as _);
pub const STATUS_TPM_20_E_KEY_SIZE: NTSTATUS = NTSTATUS(-1071054713i32 as _);
pub const STATUS_TPM_20_E_MGF: NTSTATUS = NTSTATUS(-1071054712i32 as _);
pub const STATUS_TPM_20_E_MODE: NTSTATUS = NTSTATUS(-1071054711i32 as _);
pub const STATUS_TPM_20_E_NEEDS_TEST: NTSTATUS = NTSTATUS(-1071054509i32 as _);
pub const STATUS_TPM_20_E_NONCE: NTSTATUS = NTSTATUS(-1071054705i32 as _);
pub const STATUS_TPM_20_E_NO_RESULT: NTSTATUS = NTSTATUS(-1071054508i32 as _);
pub const STATUS_TPM_20_E_NV_AUTHORIZATION: NTSTATUS = NTSTATUS(-1071054519i32 as _);
pub const STATUS_TPM_20_E_NV_DEFINED: NTSTATUS = NTSTATUS(-1071054516i32 as _);
pub const STATUS_TPM_20_E_NV_LOCKED: NTSTATUS = NTSTATUS(-1071054520i32 as _);
pub const STATUS_TPM_20_E_NV_RANGE: NTSTATUS = NTSTATUS(-1071054522i32 as _);
pub const STATUS_TPM_20_E_NV_SIZE: NTSTATUS = NTSTATUS(-1071054521i32 as _);
pub const STATUS_TPM_20_E_NV_SPACE: NTSTATUS = NTSTATUS(-1071054517i32 as _);
pub const STATUS_TPM_20_E_NV_UNINITIALIZED: NTSTATUS = NTSTATUS(-1071054518i32 as _);
pub const STATUS_TPM_20_E_PARENT: NTSTATUS = NTSTATUS(-1071054510i32 as _);
pub const STATUS_TPM_20_E_PCR: NTSTATUS = NTSTATUS(-1071054553i32 as _);
pub const STATUS_TPM_20_E_PCR_CHANGED: NTSTATUS = NTSTATUS(-1071054552i32 as _);
pub const STATUS_TPM_20_E_POLICY: NTSTATUS = NTSTATUS(-1071054554i32 as _);
pub const STATUS_TPM_20_E_POLICY_CC: NTSTATUS = NTSTATUS(-1071054684i32 as _);
pub const STATUS_TPM_20_E_POLICY_FAIL: NTSTATUS = NTSTATUS(-1071054691i32 as _);
pub const STATUS_TPM_20_E_PP: NTSTATUS = NTSTATUS(-1071054704i32 as _);
pub const STATUS_TPM_20_E_PRIVATE: NTSTATUS = NTSTATUS(-1071054581i32 as _);
pub const STATUS_TPM_20_E_RANGE: NTSTATUS = NTSTATUS(-1071054707i32 as _);
pub const STATUS_TPM_20_E_REBOOT: NTSTATUS = NTSTATUS(-1071054544i32 as _);
pub const STATUS_TPM_20_E_RESERVED_BITS: NTSTATUS = NTSTATUS(-1071054687i32 as _);
pub const STATUS_TPM_20_E_SCHEME: NTSTATUS = NTSTATUS(-1071054702i32 as _);
pub const STATUS_TPM_20_E_SELECTOR: NTSTATUS = NTSTATUS(-1071054696i32 as _);
pub const STATUS_TPM_20_E_SENSITIVE: NTSTATUS = NTSTATUS(-1071054507i32 as _);
pub const STATUS_TPM_20_E_SEQUENCE: NTSTATUS = NTSTATUS(-1071054589i32 as _);
pub const STATUS_TPM_20_E_SIGNATURE: NTSTATUS = NTSTATUS(-1071054693i32 as _);
pub const STATUS_TPM_20_E_SIZE: NTSTATUS = NTSTATUS(-1071054699i32 as _);
pub const STATUS_TPM_20_E_SYMMETRIC: NTSTATUS = NTSTATUS(-1071054698i32 as _);
pub const STATUS_TPM_20_E_TAG: NTSTATUS = NTSTATUS(-1071054697i32 as _);
pub const STATUS_TPM_20_E_TICKET: NTSTATUS = NTSTATUS(-1071054688i32 as _);
pub const STATUS_TPM_20_E_TOO_MANY_CONTEXTS: NTSTATUS = NTSTATUS(-1071054546i32 as _);
pub const STATUS_TPM_20_E_TYPE: NTSTATUS = NTSTATUS(-1071054710i32 as _);
pub const STATUS_TPM_20_E_UNBALANCED: NTSTATUS = NTSTATUS(-1071054543i32 as _);
pub const STATUS_TPM_20_E_UPGRADE: NTSTATUS = NTSTATUS(-1071054547i32 as _);
pub const STATUS_TPM_20_E_VALUE: NTSTATUS = NTSTATUS(-1071054716i32 as _);
pub const STATUS_TPM_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1071050748i32 as _);
pub const STATUS_TPM_AREA_LOCKED: NTSTATUS = NTSTATUS(-1071054788i32 as _);
pub const STATUS_TPM_AUDITFAILURE: NTSTATUS = NTSTATUS(-1071054844i32 as _);
pub const STATUS_TPM_AUDITFAIL_SUCCESSFUL: NTSTATUS = NTSTATUS(-1071054799i32 as _);
pub const STATUS_TPM_AUDITFAIL_UNSUCCESSFUL: NTSTATUS = NTSTATUS(-1071054800i32 as _);
pub const STATUS_TPM_AUTH2FAIL: NTSTATUS = NTSTATUS(-1071054819i32 as _);
pub const STATUS_TPM_AUTHFAIL: NTSTATUS = NTSTATUS(-1071054847i32 as _);
pub const STATUS_TPM_AUTH_CONFLICT: NTSTATUS = NTSTATUS(-1071054789i32 as _);
pub const STATUS_TPM_BADCONTEXT: NTSTATUS = NTSTATUS(-1071054758i32 as _);
pub const STATUS_TPM_BADINDEX: NTSTATUS = NTSTATUS(-1071054846i32 as _);
pub const STATUS_TPM_BADTAG: NTSTATUS = NTSTATUS(-1071054818i32 as _);
pub const STATUS_TPM_BAD_ATTRIBUTES: NTSTATUS = NTSTATUS(-1071054782i32 as _);
pub const STATUS_TPM_BAD_COUNTER: NTSTATUS = NTSTATUS(-1071054779i32 as _);
pub const STATUS_TPM_BAD_DATASIZE: NTSTATUS = NTSTATUS(-1071054805i32 as _);
pub const STATUS_TPM_BAD_DELEGATE: NTSTATUS = NTSTATUS(-1071054759i32 as _);
pub const STATUS_TPM_BAD_HANDLE: NTSTATUS = NTSTATUS(-1071054760i32 as _);
pub const STATUS_TPM_BAD_KEY_PROPERTY: NTSTATUS = NTSTATUS(-1071054808i32 as _);
pub const STATUS_TPM_BAD_LOCALITY: NTSTATUS = NTSTATUS(-1071054787i32 as _);
pub const STATUS_TPM_BAD_MIGRATION: NTSTATUS = NTSTATUS(-1071054807i32 as _);
pub const STATUS_TPM_BAD_MODE: NTSTATUS = NTSTATUS(-1071054804i32 as _);
pub const STATUS_TPM_BAD_ORDINAL: NTSTATUS = NTSTATUS(-1071054838i32 as _);
pub const STATUS_TPM_BAD_PARAMETER: NTSTATUS = NTSTATUS(-1071054845i32 as _);
pub const STATUS_TPM_BAD_PARAM_SIZE: NTSTATUS = NTSTATUS(-1071054823i32 as _);
pub const STATUS_TPM_BAD_PRESENCE: NTSTATUS = NTSTATUS(-1071054803i32 as _);
pub const STATUS_TPM_BAD_SCHEME: NTSTATUS = NTSTATUS(-1071054806i32 as _);
pub const STATUS_TPM_BAD_SIGNATURE: NTSTATUS = NTSTATUS(-1071054750i32 as _);
pub const STATUS_TPM_BAD_TYPE: NTSTATUS = NTSTATUS(-1071054796i32 as _);
pub const STATUS_TPM_BAD_VERSION: NTSTATUS = NTSTATUS(-1071054802i32 as _);
pub const STATUS_TPM_CLEAR_DISABLED: NTSTATUS = NTSTATUS(-1071054843i32 as _);
pub const STATUS_TPM_COMMAND_BLOCKED: NTSTATUS = NTSTATUS(-1071053824i32 as _);
pub const STATUS_TPM_COMMAND_CANCELED: NTSTATUS = NTSTATUS(-1071050751i32 as _);
pub const STATUS_TPM_CONTEXT_GAP: NTSTATUS = NTSTATUS(-1071054777i32 as _);
pub const STATUS_TPM_DAA_INPUT_DATA0: NTSTATUS = NTSTATUS(-1071054767i32 as _);
pub const STATUS_TPM_DAA_INPUT_DATA1: NTSTATUS = NTSTATUS(-1071054766i32 as _);
pub const STATUS_TPM_DAA_ISSUER_SETTINGS: NTSTATUS = NTSTATUS(-1071054765i32 as _);
pub const STATUS_TPM_DAA_ISSUER_VALIDITY: NTSTATUS = NTSTATUS(-1071054762i32 as _);
pub const STATUS_TPM_DAA_RESOURCES: NTSTATUS = NTSTATUS(-1071054768i32 as _);
pub const STATUS_TPM_DAA_STAGE: NTSTATUS = NTSTATUS(-1071054763i32 as _);
pub const STATUS_TPM_DAA_TPM_SETTINGS: NTSTATUS = NTSTATUS(-1071054764i32 as _);
pub const STATUS_TPM_DAA_WRONG_W: NTSTATUS = NTSTATUS(-1071054761i32 as _);
pub const STATUS_TPM_DEACTIVATED: NTSTATUS = NTSTATUS(-1071054842i32 as _);
pub const STATUS_TPM_DECRYPT_ERROR: NTSTATUS = NTSTATUS(-1071054815i32 as _);
pub const STATUS_TPM_DEFEND_LOCK_RUNNING: NTSTATUS = NTSTATUS(-1071052797i32 as _);
pub const STATUS_TPM_DELEGATE_ADMIN: NTSTATUS = NTSTATUS(-1071054771i32 as _);
pub const STATUS_TPM_DELEGATE_FAMILY: NTSTATUS = NTSTATUS(-1071054772i32 as _);
pub const STATUS_TPM_DELEGATE_LOCK: NTSTATUS = NTSTATUS(-1071054773i32 as _);
pub const STATUS_TPM_DISABLED: NTSTATUS = NTSTATUS(-1071054841i32 as _);
pub const STATUS_TPM_DISABLED_CMD: NTSTATUS = NTSTATUS(-1071054840i32 as _);
pub const STATUS_TPM_DOING_SELFTEST: NTSTATUS = NTSTATUS(-1071052798i32 as _);
pub const STATUS_TPM_DUPLICATE_VHANDLE: NTSTATUS = NTSTATUS(-1071053822i32 as _);
pub const STATUS_TPM_EMBEDDED_COMMAND_BLOCKED: NTSTATUS = NTSTATUS(-1071053821i32 as _);
pub const STATUS_TPM_EMBEDDED_COMMAND_UNSUPPORTED: NTSTATUS = NTSTATUS(-1071053820i32 as _);
pub const STATUS_TPM_ENCRYPT_ERROR: NTSTATUS = NTSTATUS(-1071054816i32 as _);
pub const STATUS_TPM_ERROR_MASK: NTSTATUS = NTSTATUS(-1071054848i32 as _);
pub const STATUS_TPM_FAIL: NTSTATUS = NTSTATUS(-1071054839i32 as _);
pub const STATUS_TPM_FAILEDSELFTEST: NTSTATUS = NTSTATUS(-1071054820i32 as _);
pub const STATUS_TPM_FAMILYCOUNT: NTSTATUS = NTSTATUS(-1071054784i32 as _);
pub const STATUS_TPM_INAPPROPRIATE_ENC: NTSTATUS = NTSTATUS(-1071054834i32 as _);
pub const STATUS_TPM_INAPPROPRIATE_SIG: NTSTATUS = NTSTATUS(-1071054809i32 as _);
pub const STATUS_TPM_INSTALL_DISABLED: NTSTATUS = NTSTATUS(-1071054837i32 as _);
pub const STATUS_TPM_INSUFFICIENT_BUFFER: NTSTATUS = NTSTATUS(-1071050747i32 as _);
pub const STATUS_TPM_INVALID_AUTHHANDLE: NTSTATUS = NTSTATUS(-1071054814i32 as _);
pub const STATUS_TPM_INVALID_FAMILY: NTSTATUS = NTSTATUS(-1071054793i32 as _);
pub const STATUS_TPM_INVALID_HANDLE: NTSTATUS = NTSTATUS(-1071053823i32 as _);
pub const STATUS_TPM_INVALID_KEYHANDLE: NTSTATUS = NTSTATUS(-1071054836i32 as _);
pub const STATUS_TPM_INVALID_KEYUSAGE: NTSTATUS = NTSTATUS(-1071054812i32 as _);
pub const STATUS_TPM_INVALID_PCR_INFO: NTSTATUS = NTSTATUS(-1071054832i32 as _);
pub const STATUS_TPM_INVALID_POSTINIT: NTSTATUS = NTSTATUS(-1071054810i32 as _);
pub const STATUS_TPM_INVALID_RESOURCE: NTSTATUS = NTSTATUS(-1071054795i32 as _);
pub const STATUS_TPM_INVALID_STRUCTURE: NTSTATUS = NTSTATUS(-1071054781i32 as _);
pub const STATUS_TPM_IOERROR: NTSTATUS = NTSTATUS(-1071054817i32 as _);
pub const STATUS_TPM_KEYNOTFOUND: NTSTATUS = NTSTATUS(-1071054835i32 as _);
pub const STATUS_TPM_KEY_NOTSUPPORTED: NTSTATUS = NTSTATUS(-1071054790i32 as _);
pub const STATUS_TPM_KEY_OWNER_CONTROL: NTSTATUS = NTSTATUS(-1071054780i32 as _);
pub const STATUS_TPM_MAXNVWRITES: NTSTATUS = NTSTATUS(-1071054776i32 as _);
pub const STATUS_TPM_MA_AUTHORITY: NTSTATUS = NTSTATUS(-1071054753i32 as _);
pub const STATUS_TPM_MA_DESTINATION: NTSTATUS = NTSTATUS(-1071054755i32 as _);
pub const STATUS_TPM_MA_SOURCE: NTSTATUS = NTSTATUS(-1071054754i32 as _);
pub const STATUS_TPM_MA_TICKET_SIGNATURE: NTSTATUS = NTSTATUS(-1071054756i32 as _);
pub const STATUS_TPM_MIGRATEFAIL: NTSTATUS = NTSTATUS(-1071054833i32 as _);
pub const STATUS_TPM_NEEDS_SELFTEST: NTSTATUS = NTSTATUS(-1071052799i32 as _);
pub const STATUS_TPM_NOCONTEXTSPACE: NTSTATUS = NTSTATUS(-1071054749i32 as _);
pub const STATUS_TPM_NOOPERATOR: NTSTATUS = NTSTATUS(-1071054775i32 as _);
pub const STATUS_TPM_NOSPACE: NTSTATUS = NTSTATUS(-1071054831i32 as _);
pub const STATUS_TPM_NOSRK: NTSTATUS = NTSTATUS(-1071054830i32 as _);
pub const STATUS_TPM_NOTFIPS: NTSTATUS = NTSTATUS(-1071054794i32 as _);
pub const STATUS_TPM_NOTLOCAL: NTSTATUS = NTSTATUS(-1071054797i32 as _);
pub const STATUS_TPM_NOTRESETABLE: NTSTATUS = NTSTATUS(-1071054798i32 as _);
pub const STATUS_TPM_NOTSEALED_BLOB: NTSTATUS = NTSTATUS(-1071054829i32 as _);
pub const STATUS_TPM_NOT_FOUND: NTSTATUS = NTSTATUS(-1071050749i32 as _);
pub const STATUS_TPM_NOT_FULLWRITE: NTSTATUS = NTSTATUS(-1071054778i32 as _);
pub const STATUS_TPM_NO_ENDORSEMENT: NTSTATUS = NTSTATUS(-1071054813i32 as _);
pub const STATUS_TPM_NO_NV_PERMISSION: NTSTATUS = NTSTATUS(-1071054792i32 as _);
pub const STATUS_TPM_NO_WRAP_TRANSPORT: NTSTATUS = NTSTATUS(-1071054801i32 as _);
pub const STATUS_TPM_OWNER_CONTROL: NTSTATUS = NTSTATUS(-1071054769i32 as _);
pub const STATUS_TPM_OWNER_SET: NTSTATUS = NTSTATUS(-1071054828i32 as _);
pub const STATUS_TPM_PERMANENTEK: NTSTATUS = NTSTATUS(-1071054751i32 as _);
pub const STATUS_TPM_PER_NOWRITE: NTSTATUS = NTSTATUS(-1071054785i32 as _);
pub const STATUS_TPM_PPI_FUNCTION_UNSUPPORTED: NTSTATUS = NTSTATUS(-1071050746i32 as _);
pub const STATUS_TPM_READ_ONLY: NTSTATUS = NTSTATUS(-1071054786i32 as _);
pub const STATUS_TPM_REQUIRES_SIGN: NTSTATUS = NTSTATUS(-1071054791i32 as _);
pub const STATUS_TPM_RESOURCEMISSING: NTSTATUS = NTSTATUS(-1071054774i32 as _);
pub const STATUS_TPM_RESOURCES: NTSTATUS = NTSTATUS(-1071054827i32 as _);
pub const STATUS_TPM_RETRY: NTSTATUS = NTSTATUS(-1071052800i32 as _);
pub const STATUS_TPM_SHA_ERROR: NTSTATUS = NTSTATUS(-1071054821i32 as _);
pub const STATUS_TPM_SHA_THREAD: NTSTATUS = NTSTATUS(-1071054822i32 as _);
pub const STATUS_TPM_SHORTRANDOM: NTSTATUS = NTSTATUS(-1071054826i32 as _);
pub const STATUS_TPM_SIZE: NTSTATUS = NTSTATUS(-1071054825i32 as _);
pub const STATUS_TPM_TOOMANYCONTEXTS: NTSTATUS = NTSTATUS(-1071054757i32 as _);
pub const STATUS_TPM_TOO_MANY_CONTEXTS: NTSTATUS = NTSTATUS(-1071050750i32 as _);
pub const STATUS_TPM_TRANSPORT_NOTEXCLUSIVE: NTSTATUS = NTSTATUS(-1071054770i32 as _);
pub const STATUS_TPM_WRITE_LOCKED: NTSTATUS = NTSTATUS(-1071054783i32 as _);
pub const STATUS_TPM_WRONGPCRVAL: NTSTATUS = NTSTATUS(-1071054824i32 as _);
pub const STATUS_TPM_WRONG_ENTITYTYPE: NTSTATUS = NTSTATUS(-1071054811i32 as _);
pub const STATUS_TPM_ZERO_EXHAUST_ENABLED: NTSTATUS = NTSTATUS(-1071038464i32 as _);
pub const STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE: NTSTATUS = NTSTATUS(-1072103360i32 as _);
pub const STATUS_TRANSACTIONAL_CONFLICT: NTSTATUS = NTSTATUS(-1072103423i32 as _);
pub const STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1072103361i32 as _);
pub const STATUS_TRANSACTIONMANAGER_IDENTITY_MISMATCH: NTSTATUS = NTSTATUS(-1072103332i32 as _);
pub const STATUS_TRANSACTIONMANAGER_NOT_FOUND: NTSTATUS = NTSTATUS(-1072103343i32 as _);
pub const STATUS_TRANSACTIONMANAGER_NOT_ONLINE: NTSTATUS = NTSTATUS(-1072103342i32 as _);
pub const STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION: NTSTATUS = NTSTATUS(-1072103341i32 as _);
pub const STATUS_TRANSACTIONS_NOT_FROZEN: NTSTATUS = NTSTATUS(-1072103355i32 as _);
pub const STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE: NTSTATUS = NTSTATUS(-1072103414i32 as _);
pub const STATUS_TRANSACTION_ABORTED: NTSTATUS = NTSTATUS(-1073741297i32 as _);
pub const STATUS_TRANSACTION_ALREADY_ABORTED: NTSTATUS = NTSTATUS(-1072103403i32 as _);
pub const STATUS_TRANSACTION_ALREADY_COMMITTED: NTSTATUS = NTSTATUS(-1072103402i32 as _);
pub const STATUS_TRANSACTION_FREEZE_IN_PROGRESS: NTSTATUS = NTSTATUS(-1072103354i32 as _);
pub const STATUS_TRANSACTION_INTEGRITY_VIOLATED: NTSTATUS = NTSTATUS(-1072103333i32 as _);
pub const STATUS_TRANSACTION_INVALID_ID: NTSTATUS = NTSTATUS(-1073741292i32 as _);
pub const STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER: NTSTATUS = NTSTATUS(-1072103401i32 as _);
pub const STATUS_TRANSACTION_INVALID_TYPE: NTSTATUS = NTSTATUS(-1073741291i32 as _);
pub const STATUS_TRANSACTION_MUST_WRITETHROUGH: NTSTATUS = NTSTATUS(-1072103330i32 as _);
pub const STATUS_TRANSACTION_NOT_ACTIVE: NTSTATUS = NTSTATUS(-1072103421i32 as _);
pub const STATUS_TRANSACTION_NOT_ENLISTED: NTSTATUS = NTSTATUS(-1072103327i32 as _);
pub const STATUS_TRANSACTION_NOT_FOUND: NTSTATUS = NTSTATUS(-1072103346i32 as _);
pub const STATUS_TRANSACTION_NOT_JOINED: NTSTATUS = NTSTATUS(-1072103417i32 as _);
pub const STATUS_TRANSACTION_NOT_REQUESTED: NTSTATUS = NTSTATUS(-1072103404i32 as _);
pub const STATUS_TRANSACTION_NOT_ROOT: NTSTATUS = NTSTATUS(-1072103340i32 as _);
pub const STATUS_TRANSACTION_NO_MATCH: NTSTATUS = NTSTATUS(-1073741294i32 as _);
pub const STATUS_TRANSACTION_NO_RELEASE: NTSTATUS = NTSTATUS(-1073741295i32 as _);
pub const STATUS_TRANSACTION_NO_SUPERIOR: NTSTATUS = NTSTATUS(-1072103329i32 as _);
pub const STATUS_TRANSACTION_OBJECT_EXPIRED: NTSTATUS = NTSTATUS(-1072103339i32 as _);
pub const STATUS_TRANSACTION_PROPAGATION_FAILED: NTSTATUS = NTSTATUS(-1072103408i32 as _);
pub const STATUS_TRANSACTION_RECORD_TOO_LONG: NTSTATUS = NTSTATUS(-1072103336i32 as _);
pub const STATUS_TRANSACTION_REQUEST_NOT_VALID: NTSTATUS = NTSTATUS(-1072103405i32 as _);
pub const STATUS_TRANSACTION_REQUIRED_PROMOTION: NTSTATUS = NTSTATUS(-1072103357i32 as _);
pub const STATUS_TRANSACTION_RESPONDED: NTSTATUS = NTSTATUS(-1073741293i32 as _);
pub const STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED: NTSTATUS = NTSTATUS(-1072103337i32 as _);
pub const STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET: NTSTATUS = NTSTATUS(-2145845182i32 as _);
pub const STATUS_TRANSACTION_SUPERIOR_EXISTS: NTSTATUS = NTSTATUS(-1072103406i32 as _);
pub const STATUS_TRANSACTION_TIMED_OUT: NTSTATUS = NTSTATUS(-1073741296i32 as _);
pub const STATUS_TRANSLATION_COMPLETE: NTSTATUS = NTSTATUS(288i32 as _);
pub const STATUS_TRANSPORT_FULL: NTSTATUS = NTSTATUS(-1073741110i32 as _);
pub const STATUS_TRIGGERED_EXECUTABLE_MEMORY_WRITE: NTSTATUS = NTSTATUS(-1073739994i32 as _);
pub const STATUS_TRIM_READ_ZERO_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073740686i32 as _);
pub const STATUS_TRUSTED_DOMAIN_FAILURE: NTSTATUS = NTSTATUS(-1073741428i32 as _);
pub const STATUS_TRUSTED_RELATIONSHIP_FAILURE: NTSTATUS = NTSTATUS(-1073741427i32 as _);
pub const STATUS_TRUST_FAILURE: NTSTATUS = NTSTATUS(-1073741424i32 as _);
pub const STATUS_TS_INCOMPATIBLE_SESSIONS: NTSTATUS = NTSTATUS(-1073086407i32 as _);
pub const STATUS_TS_VIDEO_SUBSYSTEM_ERROR: NTSTATUS = NTSTATUS(-1073086406i32 as _);
pub const STATUS_TXF_ATTRIBUTE_CORRUPT: NTSTATUS = NTSTATUS(-1072103363i32 as _);
pub const STATUS_TXF_DIR_NOT_EMPTY: NTSTATUS = NTSTATUS(-1072103367i32 as _);
pub const STATUS_TXF_METADATA_ALREADY_PRESENT: NTSTATUS = NTSTATUS(-2145845183i32 as _);
pub const STATUS_UNABLE_TO_DECOMMIT_VM: NTSTATUS = NTSTATUS(-1073741780i32 as _);
pub const STATUS_UNABLE_TO_DELETE_SECTION: NTSTATUS = NTSTATUS(-1073741797i32 as _);
pub const STATUS_UNABLE_TO_FREE_VM: NTSTATUS = NTSTATUS(-1073741798i32 as _);
pub const STATUS_UNABLE_TO_LOCK_MEDIA: NTSTATUS = NTSTATUS(-1073741451i32 as _);
pub const STATUS_UNABLE_TO_UNLOAD_MEDIA: NTSTATUS = NTSTATUS(-1073741450i32 as _);
pub const STATUS_UNDEFINED_CHARACTER: NTSTATUS = NTSTATUS(-1073741469i32 as _);
pub const STATUS_UNDEFINED_SCOPE: NTSTATUS = NTSTATUS(-1073740540i32 as _);
pub const STATUS_UNEXPECTED_IO_ERROR: NTSTATUS = NTSTATUS(-1073741591i32 as _);
pub const STATUS_UNEXPECTED_MM_CREATE_ERR: NTSTATUS = NTSTATUS(-1073741590i32 as _);
pub const STATUS_UNEXPECTED_MM_EXTEND_ERR: NTSTATUS = NTSTATUS(-1073741588i32 as _);
pub const STATUS_UNEXPECTED_MM_MAP_ERROR: NTSTATUS = NTSTATUS(-1073741589i32 as _);
pub const STATUS_UNEXPECTED_NETWORK_ERROR: NTSTATUS = NTSTATUS(-1073741628i32 as _);
pub const STATUS_UNFINISHED_CONTEXT_DELETED: NTSTATUS = NTSTATUS(-1073741074i32 as _);
pub const STATUS_UNHANDLED_EXCEPTION: NTSTATUS = NTSTATUS(-1073741500i32 as _);
pub const STATUS_UNKNOWN_REVISION: NTSTATUS = NTSTATUS(-1073741736i32 as _);
pub const STATUS_UNMAPPABLE_CHARACTER: NTSTATUS = NTSTATUS(-1073741470i32 as _);
pub const STATUS_UNRECOGNIZED_MEDIA: NTSTATUS = NTSTATUS(-1073741804i32 as _);
pub const STATUS_UNRECOGNIZED_VOLUME: NTSTATUS = NTSTATUS(-1073741489i32 as _);
pub const STATUS_UNSATISFIED_DEPENDENCIES: NTSTATUS = NTSTATUS(-1073740615i32 as _);
pub const STATUS_UNSUCCESSFUL: NTSTATUS = NTSTATUS(-1073741823i32 as _);
pub const STATUS_UNSUPPORTED_COMPRESSION: NTSTATUS = NTSTATUS(-1073741217i32 as _);
pub const STATUS_UNSUPPORTED_PAGING_MODE: NTSTATUS = NTSTATUS(-1073740613i32 as _);
pub const STATUS_UNSUPPORTED_PREAUTH: NTSTATUS = NTSTATUS(-1073740975i32 as _);
pub const STATUS_UNTRUSTED_MOUNT_POINT: NTSTATUS = NTSTATUS(-1073740612i32 as _);
pub const STATUS_UNWIND: NTSTATUS = NTSTATUS(-1073741785i32 as _);
pub const STATUS_UNWIND_CONSOLIDATE: NTSTATUS = NTSTATUS(-2147483607i32 as _);
pub const STATUS_USER2USER_REQUIRED: NTSTATUS = NTSTATUS(-1073740792i32 as _);
pub const STATUS_USER_APC: NTSTATUS = NTSTATUS(192i32 as _);
pub const STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1073740797i32 as _);
pub const STATUS_USER_EXISTS: NTSTATUS = NTSTATUS(-1073741725i32 as _);
pub const STATUS_USER_MAPPED_FILE: NTSTATUS = NTSTATUS(-1073741245i32 as _);
pub const STATUS_USER_SESSION_DELETED: NTSTATUS = NTSTATUS(-1073741309i32 as _);
pub const STATUS_VALIDATE_CONTINUE: NTSTATUS = NTSTATUS(-1073741199i32 as _);
pub const STATUS_VALID_CATALOG_HASH: NTSTATUS = NTSTATUS(301i32 as _);
pub const STATUS_VALID_IMAGE_HASH: NTSTATUS = NTSTATUS(300i32 as _);
pub const STATUS_VALID_STRONG_CODE_HASH: NTSTATUS = NTSTATUS(302i32 as _);
pub const STATUS_VARIABLE_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741568i32 as _);
pub const STATUS_VDM_DISALLOWED: NTSTATUS = NTSTATUS(-1073740780i32 as _);
pub const STATUS_VDM_HARD_ERROR: NTSTATUS = NTSTATUS(-1073741283i32 as _);
pub const STATUS_VERIFIER_STOP: NTSTATUS = NTSTATUS(-1073740767i32 as _);
pub const STATUS_VERIFY_REQUIRED: NTSTATUS = NTSTATUS(-2147483626i32 as _);
pub const STATUS_VHDSET_BACKING_STORAGE_NOT_FOUND: NTSTATUS = NTSTATUS(-1067647220i32 as _);
pub const STATUS_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZE: NTSTATUS = NTSTATUS(-1069940685i32 as _);
pub const STATUS_VHD_BITMAP_MISMATCH: NTSTATUS = NTSTATUS(-1069940724i32 as _);
pub const STATUS_VHD_BLOCK_ALLOCATION_FAILURE: NTSTATUS = NTSTATUS(-1069940727i32 as _);
pub const STATUS_VHD_BLOCK_ALLOCATION_TABLE_CORRUPT: NTSTATUS = NTSTATUS(-1069940726i32 as _);
pub const STATUS_VHD_CHANGE_TRACKING_DISABLED: NTSTATUS = NTSTATUS(-1069940694i32 as _);
pub const STATUS_VHD_CHILD_PARENT_ID_MISMATCH: NTSTATUS = NTSTATUS(-1069940722i32 as _);
pub const STATUS_VHD_CHILD_PARENT_SIZE_MISMATCH: NTSTATUS = NTSTATUS(-1069940713i32 as _);
pub const STATUS_VHD_CHILD_PARENT_TIMESTAMP_MISMATCH: NTSTATUS = NTSTATUS(-1069940721i32 as _);
pub const STATUS_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZE: NTSTATUS = NTSTATUS(-1069940686i32 as _);
pub const STATUS_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED: NTSTATUS = NTSTATUS(-1069940712i32 as _);
pub const STATUS_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT: NTSTATUS = NTSTATUS(-1069940711i32 as _);
pub const STATUS_VHD_DRIVE_FOOTER_CHECKSUM_MISMATCH: NTSTATUS = NTSTATUS(-1069940734i32 as _);
pub const STATUS_VHD_DRIVE_FOOTER_CORRUPT: NTSTATUS = NTSTATUS(-1069940733i32 as _);
pub const STATUS_VHD_DRIVE_FOOTER_MISSING: NTSTATUS = NTSTATUS(-1069940735i32 as _);
pub const STATUS_VHD_FORMAT_UNKNOWN: NTSTATUS = NTSTATUS(-1069940732i32 as _);
pub const STATUS_VHD_FORMAT_UNSUPPORTED_VERSION: NTSTATUS = NTSTATUS(-1069940731i32 as _);
pub const STATUS_VHD_INVALID_BLOCK_SIZE: NTSTATUS = NTSTATUS(-1069940725i32 as _);
pub const STATUS_VHD_INVALID_CHANGE_TRACKING_ID: NTSTATUS = NTSTATUS(-1069940695i32 as _);
pub const STATUS_VHD_INVALID_FILE_SIZE: NTSTATUS = NTSTATUS(-1069940717i32 as _);
pub const STATUS_VHD_INVALID_SIZE: NTSTATUS = NTSTATUS(-1069940718i32 as _);
pub const STATUS_VHD_INVALID_STATE: NTSTATUS = NTSTATUS(-1069940708i32 as _);
pub const STATUS_VHD_INVALID_TYPE: NTSTATUS = NTSTATUS(-1069940709i32 as _);
pub const STATUS_VHD_METADATA_FULL: NTSTATUS = NTSTATUS(-1069940696i32 as _);
pub const STATUS_VHD_METADATA_READ_FAILURE: NTSTATUS = NTSTATUS(-1069940720i32 as _);
pub const STATUS_VHD_METADATA_WRITE_FAILURE: NTSTATUS = NTSTATUS(-1069940719i32 as _);
pub const STATUS_VHD_MISSING_CHANGE_TRACKING_INFORMATION: NTSTATUS = NTSTATUS(-1069940688i32 as _);
pub const STATUS_VHD_PARENT_VHD_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1069940714i32 as _);
pub const STATUS_VHD_PARENT_VHD_NOT_FOUND: NTSTATUS = NTSTATUS(-1069940723i32 as _);
pub const STATUS_VHD_RESIZE_WOULD_TRUNCATE_DATA: NTSTATUS = NTSTATUS(-1069940687i32 as _);
pub const STATUS_VHD_SHARED: NTSTATUS = NTSTATUS(-1067647222i32 as _);
pub const STATUS_VHD_SPARSE_HEADER_CHECKSUM_MISMATCH: NTSTATUS = NTSTATUS(-1069940730i32 as _);
pub const STATUS_VHD_SPARSE_HEADER_CORRUPT: NTSTATUS = NTSTATUS(-1069940728i32 as _);
pub const STATUS_VHD_SPARSE_HEADER_UNSUPPORTED_VERSION: NTSTATUS = NTSTATUS(-1069940729i32 as _);
pub const STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST: NTSTATUS = NTSTATUS(1075511532i32 as _);
pub const STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD: NTSTATUS = NTSTATUS(-1071972118i32 as _);
pub const STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED: NTSTATUS = NTSTATUS(-2145713941i32 as _);
pub const STATUS_VID_CHILD_GPA_PAGE_SET_CORRUPTED: NTSTATUS = NTSTATUS(-1070137330i32 as _);
pub const STATUS_VID_DUPLICATE_HANDLER: NTSTATUS = NTSTATUS(-1070137343i32 as _);
pub const STATUS_VID_EXCEEDED_KM_CONTEXT_COUNT_LIMIT: NTSTATUS = NTSTATUS(-1070137314i32 as _);
pub const STATUS_VID_EXCEEDED_MBP_ENTRY_MAP_LIMIT: NTSTATUS = NTSTATUS(-1070137332i32 as _);
pub const STATUS_VID_HANDLER_NOT_PRESENT: NTSTATUS = NTSTATUS(-1070137340i32 as _);
pub const STATUS_VID_INVALID_CHILD_GPA_PAGE_SET: NTSTATUS = NTSTATUS(-1070137310i32 as _);
pub const STATUS_VID_INVALID_GPA_RANGE_HANDLE: NTSTATUS = NTSTATUS(-1070137323i32 as _);
pub const STATUS_VID_INVALID_MEMORY_BLOCK_HANDLE: NTSTATUS = NTSTATUS(-1070137326i32 as _);
pub const STATUS_VID_INVALID_MESSAGE_QUEUE_HANDLE: NTSTATUS = NTSTATUS(-1070137324i32 as _);
pub const STATUS_VID_INVALID_NUMA_NODE_INDEX: NTSTATUS = NTSTATUS(-1070137328i32 as _);
pub const STATUS_VID_INVALID_NUMA_SETTINGS: NTSTATUS = NTSTATUS(-1070137329i32 as _);
pub const STATUS_VID_INVALID_OBJECT_NAME: NTSTATUS = NTSTATUS(-1070137339i32 as _);
pub const STATUS_VID_INVALID_PPM_HANDLE: NTSTATUS = NTSTATUS(-1070137320i32 as _);
pub const STATUS_VID_INVALID_PROCESSOR_STATE: NTSTATUS = NTSTATUS(-1070137315i32 as _);
pub const STATUS_VID_KM_INTERFACE_ALREADY_INITIALIZED: NTSTATUS = NTSTATUS(-1070137313i32 as _);
pub const STATUS_VID_MBPS_ARE_LOCKED: NTSTATUS = NTSTATUS(-1070137319i32 as _);
pub const STATUS_VID_MBP_ALREADY_LOCKED_USING_RESERVED_PAGE: NTSTATUS = NTSTATUS(-1070137307i32 as _);
pub const STATUS_VID_MBP_COUNT_EXCEEDED_LIMIT: NTSTATUS = NTSTATUS(-1070137306i32 as _);
pub const STATUS_VID_MB_PROPERTY_ALREADY_SET_RESET: NTSTATUS = NTSTATUS(-1070137312i32 as _);
pub const STATUS_VID_MB_STILL_REFERENCED: NTSTATUS = NTSTATUS(-1070137331i32 as _);
pub const STATUS_VID_MEMORY_BLOCK_LOCK_COUNT_EXCEEDED: NTSTATUS = NTSTATUS(-1070137321i32 as _);
pub const STATUS_VID_MESSAGE_QUEUE_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1070137333i32 as _);
pub const STATUS_VID_MESSAGE_QUEUE_CLOSED: NTSTATUS = NTSTATUS(-1070137318i32 as _);
pub const STATUS_VID_MESSAGE_QUEUE_NAME_TOO_LONG: NTSTATUS = NTSTATUS(-1070137337i32 as _);
pub const STATUS_VID_MMIO_RANGE_DESTROYED: NTSTATUS = NTSTATUS(-1070137311i32 as _);
pub const STATUS_VID_NOTIFICATION_QUEUE_ALREADY_ASSOCIATED: NTSTATUS = NTSTATUS(-1070137327i32 as _);
pub const STATUS_VID_NO_MEMORY_BLOCK_NOTIFICATION_QUEUE: NTSTATUS = NTSTATUS(-1070137322i32 as _);
pub const STATUS_VID_PAGE_RANGE_OVERFLOW: NTSTATUS = NTSTATUS(-1070137325i32 as _);
pub const STATUS_VID_PARTITION_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1070137336i32 as _);
pub const STATUS_VID_PARTITION_DOES_NOT_EXIST: NTSTATUS = NTSTATUS(-1070137335i32 as _);
pub const STATUS_VID_PARTITION_NAME_NOT_FOUND: NTSTATUS = NTSTATUS(-1070137334i32 as _);
pub const STATUS_VID_PARTITION_NAME_TOO_LONG: NTSTATUS = NTSTATUS(-1070137338i32 as _);
pub const STATUS_VID_QUEUE_FULL: NTSTATUS = NTSTATUS(-1070137341i32 as _);
pub const STATUS_VID_REMOTE_NODE_PARENT_GPA_PAGES_USED: NTSTATUS = NTSTATUS(-2143879167i32 as _);
pub const STATUS_VID_RESERVE_PAGE_SET_IS_BEING_USED: NTSTATUS = NTSTATUS(-1070137309i32 as _);
pub const STATUS_VID_RESERVE_PAGE_SET_TOO_SMALL: NTSTATUS = NTSTATUS(-1070137308i32 as _);
pub const STATUS_VID_SAVED_STATE_CORRUPT: NTSTATUS = NTSTATUS(-1070137305i32 as _);
pub const STATUS_VID_SAVED_STATE_INCOMPATIBLE: NTSTATUS = NTSTATUS(-1070137303i32 as _);
pub const STATUS_VID_SAVED_STATE_UNRECOGNIZED_ITEM: NTSTATUS = NTSTATUS(-1070137304i32 as _);
pub const STATUS_VID_STOP_PENDING: NTSTATUS = NTSTATUS(-1070137316i32 as _);
pub const STATUS_VID_TOO_MANY_HANDLERS: NTSTATUS = NTSTATUS(-1070137342i32 as _);
pub const STATUS_VID_VIRTUAL_PROCESSOR_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1070137317i32 as _);
pub const STATUS_VID_VTL_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1070137302i32 as _);
pub const STATUS_VIRTDISK_DISK_ALREADY_OWNED: NTSTATUS = NTSTATUS(-1069940706i32 as _);
pub const STATUS_VIRTDISK_DISK_ONLINE_AND_WRITABLE: NTSTATUS = NTSTATUS(-1069940705i32 as _);
pub const STATUS_VIRTDISK_NOT_VIRTUAL_DISK: NTSTATUS = NTSTATUS(-1069940715i32 as _);
pub const STATUS_VIRTDISK_PROVIDER_NOT_FOUND: NTSTATUS = NTSTATUS(-1069940716i32 as _);
pub const STATUS_VIRTDISK_UNSUPPORTED_DISK_SECTOR_SIZE: NTSTATUS = NTSTATUS(-1069940707i32 as _);
pub const STATUS_VIRTUAL_CIRCUIT_CLOSED: NTSTATUS = NTSTATUS(-1073741610i32 as _);
pub const STATUS_VIRTUAL_DISK_LIMITATION: NTSTATUS = NTSTATUS(-1069940710i32 as _);
pub const STATUS_VIRUS_DELETED: NTSTATUS = NTSTATUS(-1073739513i32 as _);
pub const STATUS_VIRUS_INFECTED: NTSTATUS = NTSTATUS(-1073739514i32 as _);
pub const STATUS_VOLMGR_ALL_DISKS_FAILED: NTSTATUS = NTSTATUS(-1070071767i32 as _);
pub const STATUS_VOLMGR_BAD_BOOT_DISK: NTSTATUS = NTSTATUS(-1070071729i32 as _);
pub const STATUS_VOLMGR_DATABASE_FULL: NTSTATUS = NTSTATUS(-1070071807i32 as _);
pub const STATUS_VOLMGR_DIFFERENT_SECTOR_SIZE: NTSTATUS = NTSTATUS(-1070071730i32 as _);
pub const STATUS_VOLMGR_DISK_CONFIGURATION_CORRUPTED: NTSTATUS = NTSTATUS(-1070071806i32 as _);
pub const STATUS_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNC: NTSTATUS = NTSTATUS(-1070071805i32 as _);
pub const STATUS_VOLMGR_DISK_CONTAINS_NON_SIMPLE_VOLUME: NTSTATUS = NTSTATUS(-1070071803i32 as _);
pub const STATUS_VOLMGR_DISK_DUPLICATE: NTSTATUS = NTSTATUS(-1070071802i32 as _);
pub const STATUS_VOLMGR_DISK_DYNAMIC: NTSTATUS = NTSTATUS(-1070071801i32 as _);
pub const STATUS_VOLMGR_DISK_ID_INVALID: NTSTATUS = NTSTATUS(-1070071800i32 as _);
pub const STATUS_VOLMGR_DISK_INVALID: NTSTATUS = NTSTATUS(-1070071799i32 as _);
pub const STATUS_VOLMGR_DISK_LAST_VOTER: NTSTATUS = NTSTATUS(-1070071798i32 as _);
pub const STATUS_VOLMGR_DISK_LAYOUT_INVALID: NTSTATUS = NTSTATUS(-1070071797i32 as _);
pub const STATUS_VOLMGR_DISK_LAYOUT_NON_BASIC_BETWEEN_BASIC_PARTITIONS: NTSTATUS = NTSTATUS(-1070071796i32 as _);
pub const STATUS_VOLMGR_DISK_LAYOUT_NOT_CYLINDER_ALIGNED: NTSTATUS = NTSTATUS(-1070071795i32 as _);
pub const STATUS_VOLMGR_DISK_LAYOUT_PARTITIONS_TOO_SMALL: NTSTATUS = NTSTATUS(-1070071794i32 as _);
pub const STATUS_VOLMGR_DISK_LAYOUT_PRIMARY_BETWEEN_LOGICAL_PARTITIONS: NTSTATUS = NTSTATUS(-1070071793i32 as _);
pub const STATUS_VOLMGR_DISK_LAYOUT_TOO_MANY_PARTITIONS: NTSTATUS = NTSTATUS(-1070071792i32 as _);
pub const STATUS_VOLMGR_DISK_MISSING: NTSTATUS = NTSTATUS(-1070071791i32 as _);
pub const STATUS_VOLMGR_DISK_NOT_EMPTY: NTSTATUS = NTSTATUS(-1070071790i32 as _);
pub const STATUS_VOLMGR_DISK_NOT_ENOUGH_SPACE: NTSTATUS = NTSTATUS(-1070071789i32 as _);
pub const STATUS_VOLMGR_DISK_REVECTORING_FAILED: NTSTATUS = NTSTATUS(-1070071788i32 as _);
pub const STATUS_VOLMGR_DISK_SECTOR_SIZE_INVALID: NTSTATUS = NTSTATUS(-1070071787i32 as _);
pub const STATUS_VOLMGR_DISK_SET_NOT_CONTAINED: NTSTATUS = NTSTATUS(-1070071786i32 as _);
pub const STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_MEMBERS: NTSTATUS = NTSTATUS(-1070071785i32 as _);
pub const STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_PLEXES: NTSTATUS = NTSTATUS(-1070071784i32 as _);
pub const STATUS_VOLMGR_DYNAMIC_DISK_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1070071783i32 as _);
pub const STATUS_VOLMGR_EXTENT_ALREADY_USED: NTSTATUS = NTSTATUS(-1070071782i32 as _);
pub const STATUS_VOLMGR_EXTENT_NOT_CONTIGUOUS: NTSTATUS = NTSTATUS(-1070071781i32 as _);
pub const STATUS_VOLMGR_EXTENT_NOT_IN_PUBLIC_REGION: NTSTATUS = NTSTATUS(-1070071780i32 as _);
pub const STATUS_VOLMGR_EXTENT_NOT_SECTOR_ALIGNED: NTSTATUS = NTSTATUS(-1070071779i32 as _);
pub const STATUS_VOLMGR_EXTENT_OVERLAPS_EBR_PARTITION: NTSTATUS = NTSTATUS(-1070071778i32 as _);
pub const STATUS_VOLMGR_EXTENT_VOLUME_LENGTHS_DO_NOT_MATCH: NTSTATUS = NTSTATUS(-1070071777i32 as _);
pub const STATUS_VOLMGR_FAULT_TOLERANT_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1070071776i32 as _);
pub const STATUS_VOLMGR_INCOMPLETE_DISK_MIGRATION: NTSTATUS = NTSTATUS(-2143813630i32 as _);
pub const STATUS_VOLMGR_INCOMPLETE_REGENERATION: NTSTATUS = NTSTATUS(-2143813631i32 as _);
pub const STATUS_VOLMGR_INTERLEAVE_LENGTH_INVALID: NTSTATUS = NTSTATUS(-1070071775i32 as _);
pub const STATUS_VOLMGR_MAXIMUM_REGISTERED_USERS: NTSTATUS = NTSTATUS(-1070071774i32 as _);
pub const STATUS_VOLMGR_MEMBER_INDEX_DUPLICATE: NTSTATUS = NTSTATUS(-1070071772i32 as _);
pub const STATUS_VOLMGR_MEMBER_INDEX_INVALID: NTSTATUS = NTSTATUS(-1070071771i32 as _);
pub const STATUS_VOLMGR_MEMBER_IN_SYNC: NTSTATUS = NTSTATUS(-1070071773i32 as _);
pub const STATUS_VOLMGR_MEMBER_MISSING: NTSTATUS = NTSTATUS(-1070071770i32 as _);
pub const STATUS_VOLMGR_MEMBER_NOT_DETACHED: NTSTATUS = NTSTATUS(-1070071769i32 as _);
pub const STATUS_VOLMGR_MEMBER_REGENERATING: NTSTATUS = NTSTATUS(-1070071768i32 as _);
pub const STATUS_VOLMGR_MIRROR_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1070071717i32 as _);
pub const STATUS_VOLMGR_NOTIFICATION_RESET: NTSTATUS = NTSTATUS(-1070071764i32 as _);
pub const STATUS_VOLMGR_NOT_PRIMARY_PACK: NTSTATUS = NTSTATUS(-1070071726i32 as _);
pub const STATUS_VOLMGR_NO_REGISTERED_USERS: NTSTATUS = NTSTATUS(-1070071766i32 as _);
pub const STATUS_VOLMGR_NO_SUCH_USER: NTSTATUS = NTSTATUS(-1070071765i32 as _);
pub const STATUS_VOLMGR_NO_VALID_LOG_COPIES: NTSTATUS = NTSTATUS(-1070071720i32 as _);
pub const STATUS_VOLMGR_NUMBER_OF_DISKS_INVALID: NTSTATUS = NTSTATUS(-1070071718i32 as _);
pub const STATUS_VOLMGR_NUMBER_OF_DISKS_IN_MEMBER_INVALID: NTSTATUS = NTSTATUS(-1070071723i32 as _);
pub const STATUS_VOLMGR_NUMBER_OF_DISKS_IN_PLEX_INVALID: NTSTATUS = NTSTATUS(-1070071724i32 as _);
pub const STATUS_VOLMGR_NUMBER_OF_EXTENTS_INVALID: NTSTATUS = NTSTATUS(-1070071731i32 as _);
pub const STATUS_VOLMGR_NUMBER_OF_MEMBERS_INVALID: NTSTATUS = NTSTATUS(-1070071763i32 as _);
pub const STATUS_VOLMGR_NUMBER_OF_PLEXES_INVALID: NTSTATUS = NTSTATUS(-1070071762i32 as _);
pub const STATUS_VOLMGR_PACK_CONFIG_OFFLINE: NTSTATUS = NTSTATUS(-1070071728i32 as _);
pub const STATUS_VOLMGR_PACK_CONFIG_ONLINE: NTSTATUS = NTSTATUS(-1070071727i32 as _);
pub const STATUS_VOLMGR_PACK_CONFIG_UPDATE_FAILED: NTSTATUS = NTSTATUS(-1070071804i32 as _);
pub const STATUS_VOLMGR_PACK_DUPLICATE: NTSTATUS = NTSTATUS(-1070071761i32 as _);
pub const STATUS_VOLMGR_PACK_HAS_QUORUM: NTSTATUS = NTSTATUS(-1070071756i32 as _);
pub const STATUS_VOLMGR_PACK_ID_INVALID: NTSTATUS = NTSTATUS(-1070071760i32 as _);
pub const STATUS_VOLMGR_PACK_INVALID: NTSTATUS = NTSTATUS(-1070071759i32 as _);
pub const STATUS_VOLMGR_PACK_LOG_UPDATE_FAILED: NTSTATUS = NTSTATUS(-1070071725i32 as _);
pub const STATUS_VOLMGR_PACK_NAME_INVALID: NTSTATUS = NTSTATUS(-1070071758i32 as _);
pub const STATUS_VOLMGR_PACK_OFFLINE: NTSTATUS = NTSTATUS(-1070071757i32 as _);
pub const STATUS_VOLMGR_PACK_WITHOUT_QUORUM: NTSTATUS = NTSTATUS(-1070071755i32 as _);
pub const STATUS_VOLMGR_PARTITION_STYLE_INVALID: NTSTATUS = NTSTATUS(-1070071754i32 as _);
pub const STATUS_VOLMGR_PARTITION_UPDATE_FAILED: NTSTATUS = NTSTATUS(-1070071753i32 as _);
pub const STATUS_VOLMGR_PLEX_INDEX_DUPLICATE: NTSTATUS = NTSTATUS(-1070071751i32 as _);
pub const STATUS_VOLMGR_PLEX_INDEX_INVALID: NTSTATUS = NTSTATUS(-1070071750i32 as _);
pub const STATUS_VOLMGR_PLEX_IN_SYNC: NTSTATUS = NTSTATUS(-1070071752i32 as _);
pub const STATUS_VOLMGR_PLEX_LAST_ACTIVE: NTSTATUS = NTSTATUS(-1070071749i32 as _);
pub const STATUS_VOLMGR_PLEX_MISSING: NTSTATUS = NTSTATUS(-1070071748i32 as _);
pub const STATUS_VOLMGR_PLEX_NOT_RAID5: NTSTATUS = NTSTATUS(-1070071745i32 as _);
pub const STATUS_VOLMGR_PLEX_NOT_SIMPLE: NTSTATUS = NTSTATUS(-1070071744i32 as _);
pub const STATUS_VOLMGR_PLEX_NOT_SIMPLE_SPANNED: NTSTATUS = NTSTATUS(-1070071721i32 as _);
pub const STATUS_VOLMGR_PLEX_REGENERATING: NTSTATUS = NTSTATUS(-1070071747i32 as _);
pub const STATUS_VOLMGR_PLEX_TYPE_INVALID: NTSTATUS = NTSTATUS(-1070071746i32 as _);
pub const STATUS_VOLMGR_PRIMARY_PACK_PRESENT: NTSTATUS = NTSTATUS(-1070071719i32 as _);
pub const STATUS_VOLMGR_RAID5_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1070071716i32 as _);
pub const STATUS_VOLMGR_STRUCTURE_SIZE_INVALID: NTSTATUS = NTSTATUS(-1070071743i32 as _);
pub const STATUS_VOLMGR_TOO_MANY_NOTIFICATION_REQUESTS: NTSTATUS = NTSTATUS(-1070071742i32 as _);
pub const STATUS_VOLMGR_TRANSACTION_IN_PROGRESS: NTSTATUS = NTSTATUS(-1070071741i32 as _);
pub const STATUS_VOLMGR_UNEXPECTED_DISK_LAYOUT_CHANGE: NTSTATUS = NTSTATUS(-1070071740i32 as _);
pub const STATUS_VOLMGR_VOLUME_CONTAINS_MISSING_DISK: NTSTATUS = NTSTATUS(-1070071739i32 as _);
pub const STATUS_VOLMGR_VOLUME_ID_INVALID: NTSTATUS = NTSTATUS(-1070071738i32 as _);
pub const STATUS_VOLMGR_VOLUME_LENGTH_INVALID: NTSTATUS = NTSTATUS(-1070071737i32 as _);
pub const STATUS_VOLMGR_VOLUME_LENGTH_NOT_SECTOR_SIZE_MULTIPLE: NTSTATUS = NTSTATUS(-1070071736i32 as _);
pub const STATUS_VOLMGR_VOLUME_MIRRORED: NTSTATUS = NTSTATUS(-1070071722i32 as _);
pub const STATUS_VOLMGR_VOLUME_NOT_MIRRORED: NTSTATUS = NTSTATUS(-1070071735i32 as _);
pub const STATUS_VOLMGR_VOLUME_NOT_RETAINED: NTSTATUS = NTSTATUS(-1070071734i32 as _);
pub const STATUS_VOLMGR_VOLUME_OFFLINE: NTSTATUS = NTSTATUS(-1070071733i32 as _);
pub const STATUS_VOLMGR_VOLUME_RETAINED: NTSTATUS = NTSTATUS(-1070071732i32 as _);
pub const STATUS_VOLSNAP_ACTIVATION_TIMEOUT: NTSTATUS = NTSTATUS(-1068498940i32 as _);
pub const STATUS_VOLSNAP_BOOTFILE_NOT_VALID: NTSTATUS = NTSTATUS(-1068498941i32 as _);
pub const STATUS_VOLSNAP_HIBERNATE_READY: NTSTATUS = NTSTATUS(293i32 as _);
pub const STATUS_VOLSNAP_NO_BYPASSIO_WITH_SNAPSHOT: NTSTATUS = NTSTATUS(-1068498939i32 as _);
pub const STATUS_VOLSNAP_PREPARE_HIBERNATE: NTSTATUS = NTSTATUS(-1073740793i32 as _);
pub const STATUS_VOLUME_DIRTY: NTSTATUS = NTSTATUS(-1073739770i32 as _);
pub const STATUS_VOLUME_DISMOUNTED: NTSTATUS = NTSTATUS(-1073741202i32 as _);
pub const STATUS_VOLUME_MOUNTED: NTSTATUS = NTSTATUS(265i32 as _);
pub const STATUS_VOLUME_NOT_CLUSTER_ALIGNED: NTSTATUS = NTSTATUS(-1073740636i32 as _);
pub const STATUS_VOLUME_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073740602i32 as _);
pub const STATUS_VOLUME_NOT_UPGRADED: NTSTATUS = NTSTATUS(-1073741156i32 as _);
pub const STATUS_VOLUME_WRITE_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1073740589i32 as _);
pub const STATUS_VRF_VOLATILE_CFG_AND_IO_ENABLED: NTSTATUS = NTSTATUS(-1073738744i32 as _);
pub const STATUS_VRF_VOLATILE_NMI_REGISTERED: NTSTATUS = NTSTATUS(-1073738738i32 as _);
pub const STATUS_VRF_VOLATILE_NOT_RUNNABLE_SYSTEM: NTSTATUS = NTSTATUS(-1073738741i32 as _);
pub const STATUS_VRF_VOLATILE_NOT_STOPPABLE: NTSTATUS = NTSTATUS(-1073738743i32 as _);
pub const STATUS_VRF_VOLATILE_NOT_SUPPORTED_RULECLASS: NTSTATUS = NTSTATUS(-1073738740i32 as _);
pub const STATUS_VRF_VOLATILE_PROTECTED_DRIVER: NTSTATUS = NTSTATUS(-1073738739i32 as _);
pub const STATUS_VRF_VOLATILE_SAFE_MODE: NTSTATUS = NTSTATUS(-1073738742i32 as _);
pub const STATUS_VRF_VOLATILE_SETTINGS_CONFLICT: NTSTATUS = NTSTATUS(-1073738737i32 as _);
pub const STATUS_VSM_DMA_PROTECTION_NOT_IN_USE: NTSTATUS = NTSTATUS(-1069219839i32 as _);
pub const STATUS_VSM_NOT_INITIALIZED: NTSTATUS = NTSTATUS(-1069219840i32 as _);
pub const STATUS_WAIT_0: NTSTATUS = NTSTATUS(0i32 as _);
pub const STATUS_WAIT_1: NTSTATUS = NTSTATUS(1i32 as _);
pub const STATUS_WAIT_2: NTSTATUS = NTSTATUS(2i32 as _);
pub const STATUS_WAIT_3: NTSTATUS = NTSTATUS(3i32 as _);
pub const STATUS_WAIT_63: NTSTATUS = NTSTATUS(63i32 as _);
pub const STATUS_WAIT_FOR_OPLOCK: NTSTATUS = NTSTATUS(871i32 as _);
pub const STATUS_WAKE_SYSTEM: NTSTATUS = NTSTATUS(1073742484i32 as _);
pub const STATUS_WAKE_SYSTEM_DEBUGGER: NTSTATUS = NTSTATUS(-2147483641i32 as _);
pub const STATUS_WAS_LOCKED: NTSTATUS = NTSTATUS(1073741849i32 as _);
pub const STATUS_WAS_UNLOCKED: NTSTATUS = NTSTATUS(1073741847i32 as _);
pub const STATUS_WEAK_WHFBKEY_BLOCKED: NTSTATUS = NTSTATUS(-1073741389i32 as _);
pub const STATUS_WIM_NOT_BOOTABLE: NTSTATUS = NTSTATUS(-1073740665i32 as _);
pub const STATUS_WMI_ALREADY_DISABLED: NTSTATUS = NTSTATUS(-1073741054i32 as _);
pub const STATUS_WMI_ALREADY_ENABLED: NTSTATUS = NTSTATUS(-1073741053i32 as _);
pub const STATUS_WMI_GUID_DISCONNECTED: NTSTATUS = NTSTATUS(-1073741055i32 as _);
pub const STATUS_WMI_GUID_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741163i32 as _);
pub const STATUS_WMI_INSTANCE_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741162i32 as _);
pub const STATUS_WMI_ITEMID_NOT_FOUND: NTSTATUS = NTSTATUS(-1073741161i32 as _);
pub const STATUS_WMI_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1073741091i32 as _);
pub const STATUS_WMI_READ_ONLY: NTSTATUS = NTSTATUS(-1073741114i32 as _);
pub const STATUS_WMI_SET_FAILURE: NTSTATUS = NTSTATUS(-1073741113i32 as _);
pub const STATUS_WMI_TRY_AGAIN: NTSTATUS = NTSTATUS(-1073741160i32 as _);
pub const STATUS_WOF_FILE_RESOURCE_TABLE_CORRUPT: NTSTATUS = NTSTATUS(-1073700185i32 as _);
pub const STATUS_WOF_WIM_HEADER_CORRUPT: NTSTATUS = NTSTATUS(-1073700187i32 as _);
pub const STATUS_WOF_WIM_RESOURCE_TABLE_CORRUPT: NTSTATUS = NTSTATUS(-1073700186i32 as _);
pub const STATUS_WORKING_SET_LIMIT_RANGE: NTSTATUS = NTSTATUS(1073741826i32 as _);
pub const STATUS_WORKING_SET_QUOTA: NTSTATUS = NTSTATUS(-1073741663i32 as _);
pub const STATUS_WOW_ASSERTION: NTSTATUS = NTSTATUS(-1073702760i32 as _);
pub const STATUS_WRONG_COMPARTMENT: NTSTATUS = NTSTATUS(-1073700731i32 as _);
pub const STATUS_WRONG_CREDENTIAL_HANDLE: NTSTATUS = NTSTATUS(-1073741070i32 as _);
pub const STATUS_WRONG_EFS: NTSTATUS = NTSTATUS(-1073741169i32 as _);
pub const STATUS_WRONG_PASSWORD_CORE: NTSTATUS = NTSTATUS(-1073741495i32 as _);
pub const STATUS_WRONG_VOLUME: NTSTATUS = NTSTATUS(-1073741806i32 as _);
pub const STATUS_WX86_BREAKPOINT: NTSTATUS = NTSTATUS(1073741855i32 as _);
pub const STATUS_WX86_CONTINUE: NTSTATUS = NTSTATUS(1073741853i32 as _);
pub const STATUS_WX86_CREATEWX86TIB: NTSTATUS = NTSTATUS(1073741864i32 as _);
pub const STATUS_WX86_EXCEPTION_CHAIN: NTSTATUS = NTSTATUS(1073741858i32 as _);
pub const STATUS_WX86_EXCEPTION_CONTINUE: NTSTATUS = NTSTATUS(1073741856i32 as _);
pub const STATUS_WX86_EXCEPTION_LASTCHANCE: NTSTATUS = NTSTATUS(1073741857i32 as _);
pub const STATUS_WX86_FLOAT_STACK_CHECK: NTSTATUS = NTSTATUS(-1073741200i32 as _);
pub const STATUS_WX86_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1073741201i32 as _);
pub const STATUS_WX86_SINGLE_STEP: NTSTATUS = NTSTATUS(1073741854i32 as _);
pub const STATUS_WX86_UNSIMULATE: NTSTATUS = NTSTATUS(1073741852i32 as _);
pub const STATUS_XMLDSIG_ERROR: NTSTATUS = NTSTATUS(-1073700732i32 as _);
pub const STATUS_XML_ENCODING_MISMATCH: NTSTATUS = NTSTATUS(-1072365535i32 as _);
pub const STATUS_XML_PARSE_ERROR: NTSTATUS = NTSTATUS(-1073700733i32 as _);
pub const STG_E_ABNORMALAPIEXIT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286790i32 as _);
pub const STG_E_ACCESSDENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287035i32 as _);
pub const STG_E_BADBASEADDRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286768i32 as _);
pub const STG_E_CANTSAVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286781i32 as _);
pub const STG_E_CSS_AUTHENTICATION_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286266i32 as _);
pub const STG_E_CSS_KEY_NOT_ESTABLISHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286264i32 as _);
pub const STG_E_CSS_KEY_NOT_PRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286265i32 as _);
pub const STG_E_CSS_REGION_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286262i32 as _);
pub const STG_E_CSS_SCRAMBLED_SECTOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286263i32 as _);
pub const STG_E_DEVICE_UNRESPONSIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286518i32 as _);
pub const STG_E_DISKISWRITEPROTECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287021i32 as _);
pub const STG_E_DOCFILECORRUPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286775i32 as _);
pub const STG_E_DOCFILETOOLARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286767i32 as _);
pub const STG_E_EXTANTMARSHALLINGS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286776i32 as _);
pub const STG_E_FILEALREADYEXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286960i32 as _);
pub const STG_E_FILENOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287038i32 as _);
pub const STG_E_FIRMWARE_IMAGE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286519i32 as _);
pub const STG_E_FIRMWARE_SLOT_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286520i32 as _);
pub const STG_E_INCOMPLETE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286527i32 as _);
pub const STG_E_INSUFFICIENTMEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287032i32 as _);
pub const STG_E_INUSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286784i32 as _);
pub const STG_E_INVALIDFLAG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286785i32 as _);
pub const STG_E_INVALIDFUNCTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287039i32 as _);
pub const STG_E_INVALIDHANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287034i32 as _);
pub const STG_E_INVALIDHEADER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286789i32 as _);
pub const STG_E_INVALIDNAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286788i32 as _);
pub const STG_E_INVALIDPARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286953i32 as _);
pub const STG_E_INVALIDPOINTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287031i32 as _);
pub const STG_E_LOCKVIOLATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287007i32 as _);
pub const STG_E_MEDIUMFULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286928i32 as _);
pub const STG_E_NOMOREFILES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287022i32 as _);
pub const STG_E_NOTCURRENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286783i32 as _);
pub const STG_E_NOTFILEBASEDSTORAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286777i32 as _);
pub const STG_E_NOTSIMPLEFORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286766i32 as _);
pub const STG_E_OLDDLL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286779i32 as _);
pub const STG_E_OLDFORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286780i32 as _);
pub const STG_E_PATHNOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287037i32 as _);
pub const STG_E_PROPSETMISMATCHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286800i32 as _);
pub const STG_E_READFAULT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287010i32 as _);
pub const STG_E_RESETS_EXHAUSTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286261i32 as _);
pub const STG_E_REVERTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286782i32 as _);
pub const STG_E_SEEKERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287015i32 as _);
pub const STG_E_SHAREREQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286778i32 as _);
pub const STG_E_SHAREVIOLATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287008i32 as _);
pub const STG_E_STATUS_COPY_PROTECTION_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286267i32 as _);
pub const STG_E_TERMINATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286526i32 as _);
pub const STG_E_TOOMANYOPENFILES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287036i32 as _);
pub const STG_E_UNIMPLEMENTEDFUNCTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286786i32 as _);
pub const STG_E_UNKNOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147286787i32 as _);
pub const STG_E_WRITEFAULT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147287011i32 as _);
pub const STG_S_BLOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(197121i32 as _);
pub const STG_S_CANNOTCONSOLIDATE: ::windows::core::HRESULT = ::windows::core::HRESULT(197126i32 as _);
pub const STG_S_CONSOLIDATIONFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(197125i32 as _);
pub const STG_S_CONVERTED: ::windows::core::HRESULT = ::windows::core::HRESULT(197120i32 as _);
pub const STG_S_MONITORING: ::windows::core::HRESULT = ::windows::core::HRESULT(197123i32 as _);
pub const STG_S_MULTIPLEOPENS: ::windows::core::HRESULT = ::windows::core::HRESULT(197124i32 as _);
pub const STG_S_POWER_CYCLE_REQUIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(197127i32 as _);
pub const STG_S_RETRYNOW: ::windows::core::HRESULT = ::windows::core::HRESULT(197122i32 as _);
pub const STORE_ERROR_LICENSE_REVOKED: i32 = 15864i32;
pub const STORE_ERROR_PENDING_COM_TRANSACTION: i32 = 15863i32;
pub const STORE_ERROR_UNLICENSED: i32 = 15861i32;
pub const STORE_ERROR_UNLICENSED_USER: i32 = 15862i32;
pub const STRICT: u32 = 1u32;
pub const SUCCESS: u32 = 0u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SYSTEMTIME {
pub wYear: u16,
pub wMonth: u16,
pub wDayOfWeek: u16,
pub wDay: u16,
pub wHour: u16,
pub wMinute: u16,
pub wSecond: u16,
pub wMilliseconds: u16,
}
impl SYSTEMTIME {}
impl ::core::default::Default for SYSTEMTIME {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SYSTEMTIME {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SYSTEMTIME").field("wYear", &self.wYear).field("wMonth", &self.wMonth).field("wDayOfWeek", &self.wDayOfWeek).field("wDay", &self.wDay).field("wHour", &self.wHour).field("wMinute", &self.wMinute).field("wSecond", &self.wSecond).field("wMilliseconds", &self.wMilliseconds).finish()
}
}
impl ::core::cmp::PartialEq for SYSTEMTIME {
fn eq(&self, other: &Self) -> bool {
self.wYear == other.wYear && self.wMonth == other.wMonth && self.wDayOfWeek == other.wDayOfWeek && self.wDay == other.wDay && self.wHour == other.wHour && self.wMinute == other.wMinute && self.wSecond == other.wSecond && self.wMilliseconds == other.wMilliseconds
}
}
impl ::core::cmp::Eq for SYSTEMTIME {}
unsafe impl ::windows::core::Abi for SYSTEMTIME {
type Abi = Self;
}
pub const S_APPLICATION_ACTIVATION_ERROR_HANDLED_BY_DIALOG: ::windows::core::HRESULT = ::windows::core::HRESULT(2556505i32 as _);
pub const S_FALSE: ::windows::core::HRESULT = ::windows::core::HRESULT(1i32 as _);
pub const S_OK: ::windows::core::HRESULT = ::windows::core::HRESULT(0i32 as _);
pub const S_STORE_LAUNCHED_FOR_REMEDIATION: ::windows::core::HRESULT = ::windows::core::HRESULT(2556504i32 as _);
#[inline]
pub unsafe fn SetHandleInformation<'a, Param0: ::windows::core::IntoParam<'a, HANDLE>>(hobject: Param0, dwmask: u32, dwflags: HANDLE_FLAGS) -> BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetHandleInformation(hobject: HANDLE, dwmask: u32, dwflags: HANDLE_FLAGS) -> BOOL;
}
::core::mem::transmute(SetHandleInformation(hobject.into_param().abi(), ::core::mem::transmute(dwmask), ::core::mem::transmute(dwflags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SetLastError(dwerrcode: WIN32_ERROR) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetLastError(dwerrcode: WIN32_ERROR);
}
::core::mem::transmute(SetLastError(::core::mem::transmute(dwerrcode)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SetLastErrorEx(dwerrcode: WIN32_ERROR, dwtype: u32) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetLastErrorEx(dwerrcode: WIN32_ERROR, dwtype: u32);
}
::core::mem::transmute(SetLastErrorEx(::core::mem::transmute(dwerrcode), ::core::mem::transmute(dwtype)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SysAddRefString<'a, Param0: ::windows::core::IntoParam<'a, BSTR>>(bstrstring: Param0) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SysAddRefString(bstrstring: ::core::mem::ManuallyDrop<BSTR>) -> ::windows::core::HRESULT;
}
SysAddRefString(bstrstring.into_param().abi()).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SysAllocString<'a, Param0: ::windows::core::IntoParam<'a, PWSTR>>(psz: Param0) -> BSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SysAllocString(psz: PWSTR) -> BSTR;
}
::core::mem::transmute(SysAllocString(psz.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SysAllocStringByteLen<'a, Param0: ::windows::core::IntoParam<'a, PSTR>>(psz: Param0, len: u32) -> BSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SysAllocStringByteLen(psz: PSTR, len: u32) -> BSTR;
}
::core::mem::transmute(SysAllocStringByteLen(psz.into_param().abi(), ::core::mem::transmute(len)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SysAllocStringLen<'a, Param0: ::windows::core::IntoParam<'a, PWSTR>>(strin: Param0, ui: u32) -> BSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SysAllocStringLen(strin: PWSTR, ui: u32) -> BSTR;
}
::core::mem::transmute(SysAllocStringLen(strin.into_param().abi(), ::core::mem::transmute(ui)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SysFreeString<'a, Param0: ::windows::core::IntoParam<'a, BSTR>>(bstrstring: Param0) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SysFreeString(bstrstring: ::core::mem::ManuallyDrop<BSTR>);
}
::core::mem::transmute(SysFreeString(bstrstring.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SysReAllocString<'a, Param1: ::windows::core::IntoParam<'a, PWSTR>>(pbstr: *mut BSTR, psz: Param1) -> i32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SysReAllocString(pbstr: *mut ::core::mem::ManuallyDrop<BSTR>, psz: PWSTR) -> i32;
}
::core::mem::transmute(SysReAllocString(::core::mem::transmute(pbstr), psz.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SysReAllocStringLen<'a, Param1: ::windows::core::IntoParam<'a, PWSTR>>(pbstr: *mut BSTR, psz: Param1, len: u32) -> i32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SysReAllocStringLen(pbstr: *mut ::core::mem::ManuallyDrop<BSTR>, psz: PWSTR, len: u32) -> i32;
}
::core::mem::transmute(SysReAllocStringLen(::core::mem::transmute(pbstr), psz.into_param().abi(), ::core::mem::transmute(len)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SysReleaseString<'a, Param0: ::windows::core::IntoParam<'a, BSTR>>(bstrstring: Param0) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SysReleaseString(bstrstring: ::core::mem::ManuallyDrop<BSTR>);
}
::core::mem::transmute(SysReleaseString(bstrstring.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SysStringByteLen<'a, Param0: ::windows::core::IntoParam<'a, BSTR>>(bstr: Param0) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SysStringByteLen(bstr: ::core::mem::ManuallyDrop<BSTR>) -> u32;
}
::core::mem::transmute(SysStringByteLen(bstr.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SysStringLen<'a, Param0: ::windows::core::IntoParam<'a, BSTR>>(pbstr: Param0) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SysStringLen(pbstr: ::core::mem::ManuallyDrop<BSTR>) -> u32;
}
::core::mem::transmute(SysStringLen(pbstr.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const TBSIMP_E_BUFFER_TOO_SMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796160i32 as _);
pub const TBSIMP_E_CLEANUP_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796159i32 as _);
pub const TBSIMP_E_COMMAND_CANCELED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796149i32 as _);
pub const TBSIMP_E_COMMAND_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796143i32 as _);
pub const TBSIMP_E_DUPLICATE_VHANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796154i32 as _);
pub const TBSIMP_E_HASH_BAD_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796155i32 as _);
pub const TBSIMP_E_HASH_TABLE_FULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796138i32 as _);
pub const TBSIMP_E_INVALID_CONTEXT_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796158i32 as _);
pub const TBSIMP_E_INVALID_CONTEXT_PARAM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796157i32 as _);
pub const TBSIMP_E_INVALID_OUTPUT_POINTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796153i32 as _);
pub const TBSIMP_E_INVALID_PARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796152i32 as _);
pub const TBSIMP_E_INVALID_RESOURCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796140i32 as _);
pub const TBSIMP_E_LIST_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796146i32 as _);
pub const TBSIMP_E_LIST_NO_MORE_ITEMS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796147i32 as _);
pub const TBSIMP_E_NOTHING_TO_UNLOAD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796139i32 as _);
pub const TBSIMP_E_NOT_ENOUGH_SPACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796145i32 as _);
pub const TBSIMP_E_NOT_ENOUGH_TPM_CONTEXTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796144i32 as _);
pub const TBSIMP_E_NO_EVENT_LOG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796133i32 as _);
pub const TBSIMP_E_OUT_OF_MEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796148i32 as _);
pub const TBSIMP_E_PPI_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796135i32 as _);
pub const TBSIMP_E_RESOURCE_EXPIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796141i32 as _);
pub const TBSIMP_E_RPC_INIT_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796151i32 as _);
pub const TBSIMP_E_SCHEDULER_NOT_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796150i32 as _);
pub const TBSIMP_E_TOO_MANY_RESOURCES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796136i32 as _);
pub const TBSIMP_E_TOO_MANY_TBS_CONTEXTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796137i32 as _);
pub const TBSIMP_E_TPM_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796156i32 as _);
pub const TBSIMP_E_TPM_INCOMPATIBLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796134i32 as _);
pub const TBSIMP_E_UNKNOWN_ORDINAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796142i32 as _);
pub const TBS_E_ACCESS_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845806i32 as _);
pub const TBS_E_BAD_PARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845822i32 as _);
pub const TBS_E_BUFFER_TOO_LARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845810i32 as _);
pub const TBS_E_COMMAND_CANCELED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845811i32 as _);
pub const TBS_E_INSUFFICIENT_BUFFER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845819i32 as _);
pub const TBS_E_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845823i32 as _);
pub const TBS_E_INVALID_CONTEXT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845820i32 as _);
pub const TBS_E_INVALID_CONTEXT_PARAM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845817i32 as _);
pub const TBS_E_INVALID_OUTPUT_POINTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845821i32 as _);
pub const TBS_E_IOERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845818i32 as _);
pub const TBS_E_NO_EVENT_LOG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845807i32 as _);
pub const TBS_E_OWNERAUTH_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845803i32 as _);
pub const TBS_E_PPI_FUNCTION_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845804i32 as _);
pub const TBS_E_PPI_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845812i32 as _);
pub const TBS_E_PROVISIONING_INCOMPLETE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845802i32 as _);
pub const TBS_E_PROVISIONING_NOT_ALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845805i32 as _);
pub const TBS_E_SERVICE_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845808i32 as _);
pub const TBS_E_SERVICE_NOT_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845816i32 as _);
pub const TBS_E_SERVICE_START_PENDING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845813i32 as _);
pub const TBS_E_TOO_MANY_RESOURCES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845814i32 as _);
pub const TBS_E_TOO_MANY_TBS_CONTEXTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845815i32 as _);
pub const TBS_E_TPM_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144845809i32 as _);
pub const TPC_E_INITIALIZE_FAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220957i32 as _);
pub const TPC_E_INVALID_CONFIGURATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220935i32 as _);
pub const TPC_E_INVALID_DATA_FROM_RECOGNIZER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220934i32 as _);
pub const TPC_E_INVALID_INPUT_RECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220967i32 as _);
pub const TPC_E_INVALID_PACKET_DESCRIPTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220941i32 as _);
pub const TPC_E_INVALID_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220927i32 as _);
pub const TPC_E_INVALID_RIGHTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220938i32 as _);
pub const TPC_E_INVALID_STROKE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220958i32 as _);
pub const TPC_E_NOT_RELEVANT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220942i32 as _);
pub const TPC_E_NO_DEFAULT_TABLET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220974i32 as _);
pub const TPC_E_OUT_OF_ORDER_CALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220937i32 as _);
pub const TPC_E_QUEUE_FULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220936i32 as _);
pub const TPC_E_RECOGNIZER_NOT_REGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220939i32 as _);
pub const TPC_E_UNKNOWN_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220965i32 as _);
pub const TPC_S_INTERRUPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(262739i32 as _);
pub const TPC_S_NO_DATA_TO_PROCESS: ::windows::core::HRESULT = ::windows::core::HRESULT(262740i32 as _);
pub const TPC_S_TRUNCATED: ::windows::core::HRESULT = ::windows::core::HRESULT(262738i32 as _);
pub const TPMAPI_E_ACCESS_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796408i32 as _);
pub const TPMAPI_E_AUTHORIZATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796407i32 as _);
pub const TPMAPI_E_AUTHORIZATION_REVOKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796378i32 as _);
pub const TPMAPI_E_AUTHORIZING_KEY_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796376i32 as _);
pub const TPMAPI_E_BUFFER_TOO_SMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796410i32 as _);
pub const TPMAPI_E_EMPTY_TCG_LOG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796390i32 as _);
pub const TPMAPI_E_ENCRYPTION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796400i32 as _);
pub const TPMAPI_E_ENDORSEMENT_AUTH_NOT_NULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796379i32 as _);
pub const TPMAPI_E_FIPS_RNG_CHECK_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796391i32 as _);
pub const TPMAPI_E_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796409i32 as _);
pub const TPMAPI_E_INVALID_AUTHORIZATION_SIGNATURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796375i32 as _);
pub const TPMAPI_E_INVALID_CONTEXT_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796406i32 as _);
pub const TPMAPI_E_INVALID_CONTEXT_PARAMS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796395i32 as _);
pub const TPMAPI_E_INVALID_DELEGATE_BLOB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796396i32 as _);
pub const TPMAPI_E_INVALID_ENCODING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796402i32 as _);
pub const TPMAPI_E_INVALID_KEY_BLOB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796394i32 as _);
pub const TPMAPI_E_INVALID_KEY_PARAMS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796399i32 as _);
pub const TPMAPI_E_INVALID_KEY_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796401i32 as _);
pub const TPMAPI_E_INVALID_MIGRATION_AUTHORIZATION_BLOB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796398i32 as _);
pub const TPMAPI_E_INVALID_OUTPUT_POINTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796413i32 as _);
pub const TPMAPI_E_INVALID_OWNER_AUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796392i32 as _);
pub const TPMAPI_E_INVALID_PARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796412i32 as _);
pub const TPMAPI_E_INVALID_PCR_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796393i32 as _);
pub const TPMAPI_E_INVALID_PCR_INDEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796397i32 as _);
pub const TPMAPI_E_INVALID_POLICYAUTH_BLOB_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796370i32 as _);
pub const TPMAPI_E_INVALID_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796416i32 as _);
pub const TPMAPI_E_INVALID_TCG_LOG_ENTRY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796389i32 as _);
pub const TPMAPI_E_INVALID_TPM_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796371i32 as _);
pub const TPMAPI_E_MALFORMED_AUTHORIZATION_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796377i32 as _);
pub const TPMAPI_E_MALFORMED_AUTHORIZATION_OTHER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796373i32 as _);
pub const TPMAPI_E_MALFORMED_AUTHORIZATION_POLICY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796374i32 as _);
pub const TPMAPI_E_MESSAGE_TOO_LARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796403i32 as _);
pub const TPMAPI_E_NOT_ENOUGH_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796415i32 as _);
pub const TPMAPI_E_NO_AUTHORIZATION_CHAIN_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796382i32 as _);
pub const TPMAPI_E_NV_BITS_NOT_DEFINED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796385i32 as _);
pub const TPMAPI_E_NV_BITS_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796384i32 as _);
pub const TPMAPI_E_OUT_OF_MEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796411i32 as _);
pub const TPMAPI_E_OWNER_AUTH_NOT_NULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796380i32 as _);
pub const TPMAPI_E_POLICY_DENIES_OPERATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796386i32 as _);
pub const TPMAPI_E_SEALING_KEY_CHANGED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796372i32 as _);
pub const TPMAPI_E_SEALING_KEY_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796383i32 as _);
pub const TPMAPI_E_SVN_COUNTER_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796381i32 as _);
pub const TPMAPI_E_TBS_COMMUNICATION_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796405i32 as _);
pub const TPMAPI_E_TCG_INVALID_DIGEST_ENTRY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796387i32 as _);
pub const TPMAPI_E_TCG_SEPARATOR_ABSENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796388i32 as _);
pub const TPMAPI_E_TOO_MUCH_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796414i32 as _);
pub const TPMAPI_E_TPM_COMMAND_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144796404i32 as _);
pub const TPM_20_E_ASYMMETRIC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862079i32 as _);
pub const TPM_20_E_ATTRIBUTES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862078i32 as _);
pub const TPM_20_E_AUTHSIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861884i32 as _);
pub const TPM_20_E_AUTH_CONTEXT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861883i32 as _);
pub const TPM_20_E_AUTH_FAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862066i32 as _);
pub const TPM_20_E_AUTH_MISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861915i32 as _);
pub const TPM_20_E_AUTH_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861916i32 as _);
pub const TPM_20_E_AUTH_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861905i32 as _);
pub const TPM_20_E_BAD_AUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862046i32 as _);
pub const TPM_20_E_BAD_CONTEXT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861872i32 as _);
pub const TPM_20_E_BINDING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862043i32 as _);
pub const TPM_20_E_CANCELED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859895i32 as _);
pub const TPM_20_E_COMMAND_CODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861885i32 as _);
pub const TPM_20_E_COMMAND_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861886i32 as _);
pub const TPM_20_E_CONTEXT_GAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859903i32 as _);
pub const TPM_20_E_CPHASH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861871i32 as _);
pub const TPM_20_E_CURVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862042i32 as _);
pub const TPM_20_E_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861920i32 as _);
pub const TPM_20_E_ECC_CURVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861917i32 as _);
pub const TPM_20_E_ECC_POINT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862041i32 as _);
pub const TPM_20_E_EXCLUSIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861919i32 as _);
pub const TPM_20_E_EXPIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862045i32 as _);
pub const TPM_20_E_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861951i32 as _);
pub const TPM_20_E_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862069i32 as _);
pub const TPM_20_E_HASH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862077i32 as _);
pub const TPM_20_E_HIERARCHY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862075i32 as _);
pub const TPM_20_E_HMAC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861927i32 as _);
pub const TPM_20_E_INITIALIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861952i32 as _);
pub const TPM_20_E_INSUFFICIENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862054i32 as _);
pub const TPM_20_E_INTEGRITY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862049i32 as _);
pub const TPM_20_E_KDF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862068i32 as _);
pub const TPM_20_E_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862052i32 as _);
pub const TPM_20_E_KEY_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862073i32 as _);
pub const TPM_20_E_LOCALITY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859897i32 as _);
pub const TPM_20_E_LOCKOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859871i32 as _);
pub const TPM_20_E_MEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859900i32 as _);
pub const TPM_20_E_MGF: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862072i32 as _);
pub const TPM_20_E_MODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862071i32 as _);
pub const TPM_20_E_NEEDS_TEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861869i32 as _);
pub const TPM_20_E_NONCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862065i32 as _);
pub const TPM_20_E_NO_RESULT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861868i32 as _);
pub const TPM_20_E_NV_AUTHORIZATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861879i32 as _);
pub const TPM_20_E_NV_DEFINED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861876i32 as _);
pub const TPM_20_E_NV_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861880i32 as _);
pub const TPM_20_E_NV_RANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861882i32 as _);
pub const TPM_20_E_NV_RATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859872i32 as _);
pub const TPM_20_E_NV_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861881i32 as _);
pub const TPM_20_E_NV_SPACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861877i32 as _);
pub const TPM_20_E_NV_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859869i32 as _);
pub const TPM_20_E_NV_UNINITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861878i32 as _);
pub const TPM_20_E_OBJECT_HANDLES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859898i32 as _);
pub const TPM_20_E_OBJECT_MEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859902i32 as _);
pub const TPM_20_E_PARENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861870i32 as _);
pub const TPM_20_E_PCR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861913i32 as _);
pub const TPM_20_E_PCR_CHANGED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861912i32 as _);
pub const TPM_20_E_POLICY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861914i32 as _);
pub const TPM_20_E_POLICY_CC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862044i32 as _);
pub const TPM_20_E_POLICY_FAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862051i32 as _);
pub const TPM_20_E_PP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862064i32 as _);
pub const TPM_20_E_PRIVATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861941i32 as _);
pub const TPM_20_E_RANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862067i32 as _);
pub const TPM_20_E_REBOOT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861904i32 as _);
pub const TPM_20_E_RESERVED_BITS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862047i32 as _);
pub const TPM_20_E_RETRY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859870i32 as _);
pub const TPM_20_E_SCHEME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862062i32 as _);
pub const TPM_20_E_SELECTOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862056i32 as _);
pub const TPM_20_E_SENSITIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861867i32 as _);
pub const TPM_20_E_SEQUENCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861949i32 as _);
pub const TPM_20_E_SESSION_HANDLES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859899i32 as _);
pub const TPM_20_E_SESSION_MEMORY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859901i32 as _);
pub const TPM_20_E_SIGNATURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862053i32 as _);
pub const TPM_20_E_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862059i32 as _);
pub const TPM_20_E_SYMMETRIC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862058i32 as _);
pub const TPM_20_E_TAG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862057i32 as _);
pub const TPM_20_E_TESTING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859894i32 as _);
pub const TPM_20_E_TICKET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862048i32 as _);
pub const TPM_20_E_TOO_MANY_CONTEXTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861906i32 as _);
pub const TPM_20_E_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862070i32 as _);
pub const TPM_20_E_UNBALANCED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861903i32 as _);
pub const TPM_20_E_UPGRADE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861907i32 as _);
pub const TPM_20_E_VALUE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862076i32 as _);
pub const TPM_20_E_YIELDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144859896i32 as _);
pub const TPM_E_AREA_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862148i32 as _);
pub const TPM_E_ATTESTATION_CHALLENGE_NOT_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795630i32 as _);
pub const TPM_E_AUDITFAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862204i32 as _);
pub const TPM_E_AUDITFAIL_SUCCESSFUL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862159i32 as _);
pub const TPM_E_AUDITFAIL_UNSUCCESSFUL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862160i32 as _);
pub const TPM_E_AUTH2FAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862179i32 as _);
pub const TPM_E_AUTHFAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862207i32 as _);
pub const TPM_E_AUTH_CONFLICT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862149i32 as _);
pub const TPM_E_BADCONTEXT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862118i32 as _);
pub const TPM_E_BADINDEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862206i32 as _);
pub const TPM_E_BADTAG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862178i32 as _);
pub const TPM_E_BAD_ATTRIBUTES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862142i32 as _);
pub const TPM_E_BAD_COUNTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862139i32 as _);
pub const TPM_E_BAD_DATASIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862165i32 as _);
pub const TPM_E_BAD_DELEGATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862119i32 as _);
pub const TPM_E_BAD_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862120i32 as _);
pub const TPM_E_BAD_KEY_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862168i32 as _);
pub const TPM_E_BAD_LOCALITY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862147i32 as _);
pub const TPM_E_BAD_MIGRATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862167i32 as _);
pub const TPM_E_BAD_MODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862164i32 as _);
pub const TPM_E_BAD_ORDINAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862198i32 as _);
pub const TPM_E_BAD_PARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862205i32 as _);
pub const TPM_E_BAD_PARAM_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862183i32 as _);
pub const TPM_E_BAD_PRESENCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862163i32 as _);
pub const TPM_E_BAD_SCHEME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862166i32 as _);
pub const TPM_E_BAD_SIGNATURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862110i32 as _);
pub const TPM_E_BAD_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862156i32 as _);
pub const TPM_E_BAD_VERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862162i32 as _);
pub const TPM_E_BUFFER_LENGTH_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795618i32 as _);
pub const TPM_E_CLAIM_TYPE_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795620i32 as _);
pub const TPM_E_CLEAR_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862203i32 as _);
pub const TPM_E_COMMAND_BLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861184i32 as _);
pub const TPM_E_CONTEXT_GAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862137i32 as _);
pub const TPM_E_DAA_INPUT_DATA0: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862127i32 as _);
pub const TPM_E_DAA_INPUT_DATA1: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862126i32 as _);
pub const TPM_E_DAA_ISSUER_SETTINGS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862125i32 as _);
pub const TPM_E_DAA_ISSUER_VALIDITY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862122i32 as _);
pub const TPM_E_DAA_RESOURCES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862128i32 as _);
pub const TPM_E_DAA_STAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862123i32 as _);
pub const TPM_E_DAA_TPM_SETTINGS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862124i32 as _);
pub const TPM_E_DAA_WRONG_W: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862121i32 as _);
pub const TPM_E_DEACTIVATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862202i32 as _);
pub const TPM_E_DECRYPT_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862175i32 as _);
pub const TPM_E_DEFEND_LOCK_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144860157i32 as _);
pub const TPM_E_DELEGATE_ADMIN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862131i32 as _);
pub const TPM_E_DELEGATE_FAMILY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862132i32 as _);
pub const TPM_E_DELEGATE_LOCK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862133i32 as _);
pub const TPM_E_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862201i32 as _);
pub const TPM_E_DISABLED_CMD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862200i32 as _);
pub const TPM_E_DOING_SELFTEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144860158i32 as _);
pub const TPM_E_DUPLICATE_VHANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861182i32 as _);
pub const TPM_E_EMBEDDED_COMMAND_BLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861181i32 as _);
pub const TPM_E_EMBEDDED_COMMAND_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861180i32 as _);
pub const TPM_E_ENCRYPT_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862176i32 as _);
pub const TPM_E_ERROR_MASK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862208i32 as _);
pub const TPM_E_FAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862199i32 as _);
pub const TPM_E_FAILEDSELFTEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862180i32 as _);
pub const TPM_E_FAMILYCOUNT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862144i32 as _);
pub const TPM_E_INAPPROPRIATE_ENC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862194i32 as _);
pub const TPM_E_INAPPROPRIATE_SIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862169i32 as _);
pub const TPM_E_INSTALL_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862197i32 as _);
pub const TPM_E_INVALID_AUTHHANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862174i32 as _);
pub const TPM_E_INVALID_FAMILY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862153i32 as _);
pub const TPM_E_INVALID_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144861183i32 as _);
pub const TPM_E_INVALID_KEYHANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862196i32 as _);
pub const TPM_E_INVALID_KEYUSAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862172i32 as _);
pub const TPM_E_INVALID_OWNER_AUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795135i32 as _);
pub const TPM_E_INVALID_PCR_INFO: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862192i32 as _);
pub const TPM_E_INVALID_POSTINIT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862170i32 as _);
pub const TPM_E_INVALID_RESOURCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862155i32 as _);
pub const TPM_E_INVALID_STRUCTURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862141i32 as _);
pub const TPM_E_IOERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862177i32 as _);
pub const TPM_E_KEYNOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862195i32 as _);
pub const TPM_E_KEY_ALREADY_FINALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795628i32 as _);
pub const TPM_E_KEY_NOTSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862150i32 as _);
pub const TPM_E_KEY_NOT_AUTHENTICATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795624i32 as _);
pub const TPM_E_KEY_NOT_FINALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795631i32 as _);
pub const TPM_E_KEY_NOT_LOADED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795633i32 as _);
pub const TPM_E_KEY_NOT_SIGNING_KEY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795622i32 as _);
pub const TPM_E_KEY_OWNER_CONTROL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862140i32 as _);
pub const TPM_E_KEY_USAGE_POLICY_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795626i32 as _);
pub const TPM_E_KEY_USAGE_POLICY_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795627i32 as _);
pub const TPM_E_LOCKED_OUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795621i32 as _);
pub const TPM_E_MAXNVWRITES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862136i32 as _);
pub const TPM_E_MA_AUTHORITY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862113i32 as _);
pub const TPM_E_MA_DESTINATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862115i32 as _);
pub const TPM_E_MA_SOURCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862114i32 as _);
pub const TPM_E_MA_TICKET_SIGNATURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862116i32 as _);
pub const TPM_E_MIGRATEFAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862193i32 as _);
pub const TPM_E_NEEDS_SELFTEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144860159i32 as _);
pub const TPM_E_NOCONTEXTSPACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862109i32 as _);
pub const TPM_E_NOOPERATOR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862135i32 as _);
pub const TPM_E_NOSPACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862191i32 as _);
pub const TPM_E_NOSRK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862190i32 as _);
pub const TPM_E_NOTFIPS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862154i32 as _);
pub const TPM_E_NOTLOCAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862157i32 as _);
pub const TPM_E_NOTRESETABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862158i32 as _);
pub const TPM_E_NOTSEALED_BLOB: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862189i32 as _);
pub const TPM_E_NOT_FULLWRITE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862138i32 as _);
pub const TPM_E_NOT_PCR_BOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795629i32 as _);
pub const TPM_E_NO_ENDORSEMENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862173i32 as _);
pub const TPM_E_NO_KEY_CERTIFICATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795632i32 as _);
pub const TPM_E_NO_NV_PERMISSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862152i32 as _);
pub const TPM_E_NO_WRAP_TRANSPORT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862161i32 as _);
pub const TPM_E_OWNER_CONTROL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862129i32 as _);
pub const TPM_E_OWNER_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862188i32 as _);
pub const TPM_E_PCP_AUTHENTICATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795640i32 as _);
pub const TPM_E_PCP_AUTHENTICATION_IGNORED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795639i32 as _);
pub const TPM_E_PCP_BUFFER_TOO_SMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795642i32 as _);
pub const TPM_E_PCP_DEVICE_NOT_READY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795647i32 as _);
pub const TPM_E_PCP_ERROR_MASK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795648i32 as _);
pub const TPM_E_PCP_FLAG_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795644i32 as _);
pub const TPM_E_PCP_IFX_RSA_KEY_CREATION_BLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795617i32 as _);
pub const TPM_E_PCP_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795641i32 as _);
pub const TPM_E_PCP_INVALID_HANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795646i32 as _);
pub const TPM_E_PCP_INVALID_PARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795645i32 as _);
pub const TPM_E_PCP_KEY_HANDLE_INVALIDATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795614i32 as _);
pub const TPM_E_PCP_KEY_NOT_AIK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795623i32 as _);
pub const TPM_E_PCP_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795643i32 as _);
pub const TPM_E_PCP_PLATFORM_CLAIM_MAY_BE_OUTDATED: ::windows::core::HRESULT = ::windows::core::HRESULT(1076429860i32 as _);
pub const TPM_E_PCP_PLATFORM_CLAIM_OUTDATED: ::windows::core::HRESULT = ::windows::core::HRESULT(1076429861i32 as _);
pub const TPM_E_PCP_PLATFORM_CLAIM_REBOOT: ::windows::core::HRESULT = ::windows::core::HRESULT(1076429862i32 as _);
pub const TPM_E_PCP_POLICY_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795638i32 as _);
pub const TPM_E_PCP_PROFILE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795637i32 as _);
pub const TPM_E_PCP_RAW_POLICY_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795615i32 as _);
pub const TPM_E_PCP_TICKET_MISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795616i32 as _);
pub const TPM_E_PCP_UNSUPPORTED_PSS_SALT: ::windows::core::HRESULT = ::windows::core::HRESULT(1076429859i32 as _);
pub const TPM_E_PCP_VALIDATION_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795636i32 as _);
pub const TPM_E_PCP_WRONG_PARENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795634i32 as _);
pub const TPM_E_PERMANENTEK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862111i32 as _);
pub const TPM_E_PER_NOWRITE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862145i32 as _);
pub const TPM_E_PPI_ACPI_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795904i32 as _);
pub const TPM_E_PPI_BIOS_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795902i32 as _);
pub const TPM_E_PPI_BLOCKED_IN_BIOS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795900i32 as _);
pub const TPM_E_PPI_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795901i32 as _);
pub const TPM_E_PPI_USER_ABORT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795903i32 as _);
pub const TPM_E_PROVISIONING_INCOMPLETE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795136i32 as _);
pub const TPM_E_READ_ONLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862146i32 as _);
pub const TPM_E_REQUIRES_SIGN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862151i32 as _);
pub const TPM_E_RESOURCEMISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862134i32 as _);
pub const TPM_E_RESOURCES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862187i32 as _);
pub const TPM_E_RETRY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144860160i32 as _);
pub const TPM_E_SHA_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862181i32 as _);
pub const TPM_E_SHA_THREAD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862182i32 as _);
pub const TPM_E_SHORTRANDOM: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862186i32 as _);
pub const TPM_E_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862185i32 as _);
pub const TPM_E_SOFT_KEY_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795625i32 as _);
pub const TPM_E_TOOMANYCONTEXTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862117i32 as _);
pub const TPM_E_TOO_MUCH_DATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795134i32 as _);
pub const TPM_E_TRANSPORT_NOTEXCLUSIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862130i32 as _);
pub const TPM_E_VERSION_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795619i32 as _);
pub const TPM_E_WRITE_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862143i32 as _);
pub const TPM_E_WRONGPCRVAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862184i32 as _);
pub const TPM_E_WRONG_ENTITYTYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144862171i32 as _);
pub const TPM_E_ZERO_EXHAUST_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144795392i32 as _);
pub const TRUST_E_ACTION_UNKNOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762750i32 as _);
pub const TRUST_E_BAD_DIGEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146869232i32 as _);
pub const TRUST_E_BASIC_CONSTRAINTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146869223i32 as _);
pub const TRUST_E_CERT_SIGNATURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146869244i32 as _);
pub const TRUST_E_COUNTER_SIGNER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146869245i32 as _);
pub const TRUST_E_EXPLICIT_DISTRUST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762479i32 as _);
pub const TRUST_E_FAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762485i32 as _);
pub const TRUST_E_FINANCIAL_CRITERIA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146869218i32 as _);
pub const TRUST_E_MALFORMED_SIGNATURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146869231i32 as _);
pub const TRUST_E_NOSIGNATURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762496i32 as _);
pub const TRUST_E_NO_SIGNER_CERT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146869246i32 as _);
pub const TRUST_E_PROVIDER_UNKNOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762751i32 as _);
pub const TRUST_E_SUBJECT_FORM_UNKNOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762749i32 as _);
pub const TRUST_E_SUBJECT_NOT_TRUSTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146762748i32 as _);
pub const TRUST_E_SYSTEM_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146869247i32 as _);
pub const TRUST_E_TIME_STAMP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146869243i32 as _);
pub const TYPE_E_AMBIGUOUSNAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319764i32 as _);
pub const TYPE_E_BADMODULEKIND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147317571i32 as _);
pub const TYPE_E_BUFFERTOOSMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319786i32 as _);
pub const TYPE_E_CANTCREATETMPFILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147316573i32 as _);
pub const TYPE_E_CANTLOADLIBRARY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147312566i32 as _);
pub const TYPE_E_CIRCULARTYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147312508i32 as _);
pub const TYPE_E_DLLFUNCTIONNOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319761i32 as _);
pub const TYPE_E_DUPLICATEID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147317562i32 as _);
pub const TYPE_E_ELEMENTNOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319765i32 as _);
pub const TYPE_E_FIELDNOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319785i32 as _);
pub const TYPE_E_INCONSISTENTPROPFUNCS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147312509i32 as _);
pub const TYPE_E_INVALIDID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147317553i32 as _);
pub const TYPE_E_INVALIDSTATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319767i32 as _);
pub const TYPE_E_INVDATAREAD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319784i32 as _);
pub const TYPE_E_IOERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147316574i32 as _);
pub const TYPE_E_LIBNOTREGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319779i32 as _);
pub const TYPE_E_NAMECONFLICT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319763i32 as _);
pub const TYPE_E_OUTOFBOUNDS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147316575i32 as _);
pub const TYPE_E_QUALIFIEDNAMEDISALLOWED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319768i32 as _);
pub const TYPE_E_REGISTRYACCESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319780i32 as _);
pub const TYPE_E_SIZETOOBIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147317563i32 as _);
pub const TYPE_E_TYPEMISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147316576i32 as _);
pub const TYPE_E_UNDEFINEDTYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319769i32 as _);
pub const TYPE_E_UNKNOWNLCID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319762i32 as _);
pub const TYPE_E_UNSUPFORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319783i32 as _);
pub const TYPE_E_WRONGTYPEKIND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147319766i32 as _);
pub const UCEERR_BLOCKSFULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303415i32 as _);
pub const UCEERR_CHANNELSYNCABANDONED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303404i32 as _);
pub const UCEERR_CHANNELSYNCTIMEDOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303405i32 as _);
pub const UCEERR_COMMANDTRANSPORTDENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303400i32 as _);
pub const UCEERR_CONNECTIONIDLOOKUPFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303416i32 as _);
pub const UCEERR_CTXSTACKFRSTTARGETNULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303417i32 as _);
pub const UCEERR_FEEDBACK_UNSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303401i32 as _);
pub const UCEERR_GRAPHICSSTREAMALREADYOPEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303392i32 as _);
pub const UCEERR_GRAPHICSSTREAMUNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303399i32 as _);
pub const UCEERR_HANDLELOOKUPFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303419i32 as _);
pub const UCEERR_ILLEGALHANDLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303420i32 as _);
pub const UCEERR_ILLEGALPACKET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303422i32 as _);
pub const UCEERR_ILLEGALRECORDTYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303412i32 as _);
pub const UCEERR_INVALIDPACKETHEADER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303424i32 as _);
pub const UCEERR_MALFORMEDPACKET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303421i32 as _);
pub const UCEERR_MEMORYFAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303414i32 as _);
pub const UCEERR_MISSINGBEGINCOMMAND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303406i32 as _);
pub const UCEERR_MISSINGENDCOMMAND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303407i32 as _);
pub const UCEERR_NO_MULTIPLE_WORKER_THREADS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303409i32 as _);
pub const UCEERR_OUTOFHANDLES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303411i32 as _);
pub const UCEERR_PACKETRECORDOUTOFRANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303413i32 as _);
pub const UCEERR_PARTITION_ZOMBIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303389i32 as _);
pub const UCEERR_REMOTINGNOTSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303408i32 as _);
pub const UCEERR_RENDERTHREADFAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303418i32 as _);
pub const UCEERR_TRANSPORTDISCONNECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303391i32 as _);
pub const UCEERR_TRANSPORTOVERLOADED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303390i32 as _);
pub const UCEERR_TRANSPORTUNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303402i32 as _);
pub const UCEERR_UNCHANGABLE_UPDATE_ATTEMPTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303410i32 as _);
pub const UCEERR_UNKNOWNPACKET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303423i32 as _);
pub const UCEERR_UNSUPPORTEDTRANSPORTVERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003303403i32 as _);
pub const UI_E_AMBIGUOUS_MATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144731126i32 as _);
pub const UI_E_BOOLEAN_EXPECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144731128i32 as _);
pub const UI_E_CREATE_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144731135i32 as _);
pub const UI_E_DIFFERENT_OWNER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144731127i32 as _);
pub const UI_E_END_KEYFRAME_NOT_DETERMINED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144730876i32 as _);
pub const UI_E_FP_OVERFLOW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144731125i32 as _);
pub const UI_E_ILLEGAL_REENTRANCY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144731133i32 as _);
pub const UI_E_INVALID_DIMENSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144730869i32 as _);
pub const UI_E_INVALID_OUTPUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144731129i32 as _);
pub const UI_E_LOOPS_OVERLAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144730875i32 as _);
pub const UI_E_OBJECT_SEALED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144731132i32 as _);
pub const UI_E_PRIMITIVE_OUT_OF_BOUNDS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144730868i32 as _);
pub const UI_E_SHUTDOWN_CALLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144731134i32 as _);
pub const UI_E_START_KEYFRAME_AFTER_END: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144730877i32 as _);
pub const UI_E_STORYBOARD_ACTIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144730879i32 as _);
pub const UI_E_STORYBOARD_NOT_PLAYING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144730878i32 as _);
pub const UI_E_TIMER_CLIENT_ALREADY_CONNECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144730870i32 as _);
pub const UI_E_TIME_BEFORE_LAST_UPDATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144730871i32 as _);
pub const UI_E_TRANSITION_ALREADY_USED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144730874i32 as _);
pub const UI_E_TRANSITION_ECLIPSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144730872i32 as _);
pub const UI_E_TRANSITION_NOT_IN_STORYBOARD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144730873i32 as _);
pub const UI_E_VALUE_NOT_DETERMINED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144731130i32 as _);
pub const UI_E_VALUE_NOT_SET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144731131i32 as _);
pub const UI_E_WINDOW_CLOSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144730623i32 as _);
pub const UI_E_WRONG_THREAD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2144731124i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct UNICODE_STRING {
pub Length: u16,
pub MaximumLength: u16,
pub Buffer: PWSTR,
}
impl UNICODE_STRING {}
impl ::core::default::Default for UNICODE_STRING {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for UNICODE_STRING {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("UNICODE_STRING").field("Length", &self.Length).field("MaximumLength", &self.MaximumLength).field("Buffer", &self.Buffer).finish()
}
}
impl ::core::cmp::PartialEq for UNICODE_STRING {
fn eq(&self, other: &Self) -> bool {
self.Length == other.Length && self.MaximumLength == other.MaximumLength && self.Buffer == other.Buffer
}
}
impl ::core::cmp::Eq for UNICODE_STRING {}
unsafe impl ::windows::core::Abi for UNICODE_STRING {
type Abi = Self;
}
pub const UTC_E_ACTION_NOT_SUPPORTED_IN_DESTINATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128380i32 as _);
pub const UTC_E_AGENT_DIAGNOSTICS_TOO_LARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128363i32 as _);
pub const UTC_E_ALTERNATIVE_TRACE_CANNOT_PREEMPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128446i32 as _);
pub const UTC_E_AOT_NOT_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128445i32 as _);
pub const UTC_E_API_BUSY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128405i32 as _);
pub const UTC_E_API_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128388i32 as _);
pub const UTC_E_API_RESULT_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128408i32 as _);
pub const UTC_E_BINARY_MISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128396i32 as _);
pub const UTC_E_CANNOT_LOAD_SCENARIO_EDITOR_XML: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128417i32 as _);
pub const UTC_E_CERT_REV_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128385i32 as _);
pub const UTC_E_CHILD_PROCESS_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128419i32 as _);
pub const UTC_E_COMMAND_LINE_NOT_AUTHORIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128418i32 as _);
pub const UTC_E_DELAY_TERMINATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128411i32 as _);
pub const UTC_E_DEVICE_TICKET_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128410i32 as _);
pub const UTC_E_DIAGRULES_SCHEMAVERSION_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128438i32 as _);
pub const UTC_E_ESCALATION_ALREADY_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128433i32 as _);
pub const UTC_E_ESCALATION_CANCELLED_AT_SHUTDOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128358i32 as _);
pub const UTC_E_ESCALATION_DIRECTORY_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128401i32 as _);
pub const UTC_E_ESCALATION_NOT_AUTHORIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128421i32 as _);
pub const UTC_E_ESCALATION_TIMED_OUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128416i32 as _);
pub const UTC_E_EVENTLOG_ENTRY_MALFORMED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128439i32 as _);
pub const UTC_E_EXCLUSIVITY_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128403i32 as _);
pub const UTC_E_EXE_TERMINATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128422i32 as _);
pub const UTC_E_FAILED_TO_RECEIVE_AGENT_DIAGNOSTICS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128362i32 as _);
pub const UTC_E_FAILED_TO_RESOLVE_CONTAINER_ID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128394i32 as _);
pub const UTC_E_FAILED_TO_START_NDISCAP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128384i32 as _);
pub const UTC_E_FILTER_FUNCTION_RESTRICTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128376i32 as _);
pub const UTC_E_FILTER_ILLEGAL_EVAL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128365i32 as _);
pub const UTC_E_FILTER_INVALID_COMMAND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128366i32 as _);
pub const UTC_E_FILTER_INVALID_FUNCTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128368i32 as _);
pub const UTC_E_FILTER_INVALID_FUNCTION_PARAMS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128367i32 as _);
pub const UTC_E_FILTER_INVALID_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128378i32 as _);
pub const UTC_E_FILTER_MISSING_ATTRIBUTE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128379i32 as _);
pub const UTC_E_FILTER_VARIABLE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128377i32 as _);
pub const UTC_E_FILTER_VERSION_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128375i32 as _);
pub const UTC_E_FORWARDER_ALREADY_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128440i32 as _);
pub const UTC_E_FORWARDER_ALREADY_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128441i32 as _);
pub const UTC_E_FORWARDER_PRODUCER_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128430i32 as _);
pub const UTC_E_GETFILEINFOACTION_FILE_NOT_APPROVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128357i32 as _);
pub const UTC_E_GETFILE_EXTERNAL_PATH_NOT_APPROVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128387i32 as _);
pub const UTC_E_GETFILE_FILE_PATH_NOT_APPROVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128402i32 as _);
pub const UTC_E_INSUFFICIENT_SPACE_TO_START_TRACE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128359i32 as _);
pub const UTC_E_INTENTIONAL_SCRIPT_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128429i32 as _);
pub const UTC_E_INVALID_AGGREGATION_STRUCT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128381i32 as _);
pub const UTC_E_INVALID_CUSTOM_FILTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128436i32 as _);
pub const UTC_E_INVALID_FILTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128423i32 as _);
pub const UTC_E_KERNELDUMP_LIMIT_REACHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128383i32 as _);
pub const UTC_E_MISSING_AGGREGATE_EVENT_TAG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128382i32 as _);
pub const UTC_E_MULTIPLE_TIME_TRIGGER_ON_SINGLE_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128397i32 as _);
pub const UTC_E_NO_WER_LOGGER_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128427i32 as _);
pub const UTC_E_PERFTRACK_ALREADY_TRACING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128432i32 as _);
pub const UTC_E_REACHED_MAX_ESCALATIONS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128431i32 as _);
pub const UTC_E_REESCALATED_TOO_QUICKLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128434i32 as _);
pub const UTC_E_RPC_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128407i32 as _);
pub const UTC_E_RPC_WAIT_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128406i32 as _);
pub const UTC_E_SCENARIODEF_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128443i32 as _);
pub const UTC_E_SCENARIODEF_SCHEMAVERSION_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128424i32 as _);
pub const UTC_E_SCENARIO_HAS_NO_ACTIONS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128361i32 as _);
pub const UTC_E_SCENARIO_THROTTLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128389i32 as _);
pub const UTC_E_SCRIPT_MISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128390i32 as _);
pub const UTC_E_SCRIPT_TERMINATED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128437i32 as _);
pub const UTC_E_SCRIPT_TYPE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128444i32 as _);
pub const UTC_E_SETREGKEYACTION_TYPE_NOT_APPROVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128356i32 as _);
pub const UTC_E_SETUP_NOT_AUTHORIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128420i32 as _);
pub const UTC_E_SETUP_TIMED_OUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128415i32 as _);
pub const UTC_E_SIF_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128412i32 as _);
pub const UTC_E_SQM_INIT_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128428i32 as _);
pub const UTC_E_THROTTLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128392i32 as _);
pub const UTC_E_TIME_TRIGGER_INVALID_TIME_RANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128398i32 as _);
pub const UTC_E_TIME_TRIGGER_ONLY_VALID_ON_SINGLE_TRANSITION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128399i32 as _);
pub const UTC_E_TIME_TRIGGER_ON_START_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128400i32 as _);
pub const UTC_E_TOGGLE_TRACE_STARTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128447i32 as _);
pub const UTC_E_TRACEPROFILE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128442i32 as _);
pub const UTC_E_TRACERS_DONT_EXIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128426i32 as _);
pub const UTC_E_TRACE_BUFFER_LIMIT_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128409i32 as _);
pub const UTC_E_TRACE_MIN_DURATION_REQUIREMENT_NOT_MET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128404i32 as _);
pub const UTC_E_TRACE_NOT_RUNNING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128435i32 as _);
pub const UTC_E_TRACE_THROTTLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128355i32 as _);
pub const UTC_E_TRIGGER_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128414i32 as _);
pub const UTC_E_TRIGGER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128413i32 as _);
pub const UTC_E_TRY_GET_SCENARIO_TIMEOUT_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128386i32 as _);
pub const UTC_E_TTTRACER_RETURNED_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128364i32 as _);
pub const UTC_E_TTTRACER_STORAGE_FULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128360i32 as _);
pub const UTC_E_UNABLE_TO_RESOLVE_SESSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128393i32 as _);
pub const UTC_E_UNAPPROVED_SCRIPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128391i32 as _);
pub const UTC_E_WINRT_INIT_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2017128425i32 as _);
pub const VIEW_E_DRAW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147221184i32 as _);
pub const VIEW_E_FIRST: i32 = -2147221184i32;
pub const VIEW_E_LAST: i32 = -2147221169i32;
pub const VIEW_S_ALREADY_FROZEN: ::windows::core::HRESULT = ::windows::core::HRESULT(262464i32 as _);
pub const VIEW_S_FIRST: i32 = 262464i32;
pub const VIEW_S_LAST: i32 = 262479i32;
pub const VM_SAVED_STATE_DUMP_E_GUEST_MEMORY_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1070136063i32 as _);
pub const VM_SAVED_STATE_DUMP_E_INVALID_VP_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1070136058i32 as _);
pub const VM_SAVED_STATE_DUMP_E_NESTED_VIRTUALIZATION_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1070136061i32 as _);
pub const VM_SAVED_STATE_DUMP_E_NO_VP_FOUND_IN_PARTITION_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1070136062i32 as _);
pub const VM_SAVED_STATE_DUMP_E_PARTITION_STATE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1070136064i32 as _);
pub const VM_SAVED_STATE_DUMP_E_VA_NOT_MAPPED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1070136059i32 as _);
pub const VM_SAVED_STATE_DUMP_E_VP_VTL_NOT_ENABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-1070136055i32 as _);
pub const VM_SAVED_STATE_DUMP_E_WINDOWS_KERNEL_IMAGE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1070136060i32 as _);
pub const WARNING_IPSEC_MM_POLICY_PRUNED: i32 = 13024i32;
pub const WARNING_IPSEC_QM_POLICY_PRUNED: i32 = 13025i32;
pub const WARNING_NO_MD5_MIGRATION: u32 = 946u32;
pub const WBREAK_E_BUFFER_TOO_SMALL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215485i32 as _);
pub const WBREAK_E_END_OF_TEXT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215488i32 as _);
pub const WBREAK_E_INIT_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215483i32 as _);
pub const WBREAK_E_QUERY_ONLY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147215486i32 as _);
pub const WEB_E_INVALID_JSON_NUMBER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089484280i32 as _);
pub const WEB_E_INVALID_JSON_STRING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089484281i32 as _);
pub const WEB_E_INVALID_XML: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089484286i32 as _);
pub const WEB_E_JSON_VALUE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089484279i32 as _);
pub const WEB_E_MISSING_REQUIRED_ATTRIBUTE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089484284i32 as _);
pub const WEB_E_MISSING_REQUIRED_ELEMENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089484285i32 as _);
pub const WEB_E_RESOURCE_TOO_LARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089484282i32 as _);
pub const WEB_E_UNEXPECTED_CONTENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089484283i32 as _);
pub const WEB_E_UNSUPPORTED_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2089484287i32 as _);
pub const WEP_E_BUFFER_TOO_LARGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013200375i32 as _);
pub const WEP_E_FIXED_DATA_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013200382i32 as _);
pub const WEP_E_HARDWARE_NOT_COMPLIANT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013200381i32 as _);
pub const WEP_E_LOCK_NOT_CONFIGURED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013200380i32 as _);
pub const WEP_E_NOT_PROVISIONED_ON_ALL_VOLUMES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013200383i32 as _);
pub const WEP_E_NO_LICENSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013200378i32 as _);
pub const WEP_E_OS_NOT_PROTECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013200377i32 as _);
pub const WEP_E_PROTECTION_SUSPENDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013200379i32 as _);
pub const WEP_E_UNEXPECTED_FAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2013200376i32 as _);
pub const WER_E_ALREADY_REPORTING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145681404i32 as _);
pub const WER_E_CANCELED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145681407i32 as _);
pub const WER_E_CRASH_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145681408i32 as _);
pub const WER_E_DUMP_THROTTLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145681403i32 as _);
pub const WER_E_INSUFFICIENT_CONSENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145681402i32 as _);
pub const WER_E_NETWORK_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145681406i32 as _);
pub const WER_E_NOT_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145681405i32 as _);
pub const WER_E_TOO_HEAVY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2145681401i32 as _);
pub const WER_S_ASSERT_CONTINUE: ::windows::core::HRESULT = ::windows::core::HRESULT(1769482i32 as _);
pub const WER_S_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(1769475i32 as _);
pub const WER_S_DISABLED_ARCHIVE: ::windows::core::HRESULT = ::windows::core::HRESULT(1769478i32 as _);
pub const WER_S_DISABLED_QUEUE: ::windows::core::HRESULT = ::windows::core::HRESULT(1769477i32 as _);
pub const WER_S_IGNORE_ALL_ASSERTS: ::windows::core::HRESULT = ::windows::core::HRESULT(1769481i32 as _);
pub const WER_S_IGNORE_ASSERT_INSTANCE: ::windows::core::HRESULT = ::windows::core::HRESULT(1769480i32 as _);
pub const WER_S_REPORT_ASYNC: ::windows::core::HRESULT = ::windows::core::HRESULT(1769479i32 as _);
pub const WER_S_REPORT_DEBUG: ::windows::core::HRESULT = ::windows::core::HRESULT(1769472i32 as _);
pub const WER_S_REPORT_QUEUED: ::windows::core::HRESULT = ::windows::core::HRESULT(1769474i32 as _);
pub const WER_S_REPORT_UPLOADED: ::windows::core::HRESULT = ::windows::core::HRESULT(1769473i32 as _);
pub const WER_S_REPORT_UPLOADED_CAB: ::windows::core::HRESULT = ::windows::core::HRESULT(1769484i32 as _);
pub const WER_S_SUSPENDED_UPLOAD: ::windows::core::HRESULT = ::windows::core::HRESULT(1769476i32 as _);
pub const WER_S_THROTTLED: ::windows::core::HRESULT = ::windows::core::HRESULT(1769483i32 as _);
pub const WHV_E_GPA_RANGE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878395i32 as _);
pub const WHV_E_INSUFFICIENT_BUFFER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878399i32 as _);
pub const WHV_E_INVALID_PARTITION_CONFIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878396i32 as _);
pub const WHV_E_INVALID_VP_REGISTER_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878391i32 as _);
pub const WHV_E_INVALID_VP_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878392i32 as _);
pub const WHV_E_UNKNOWN_CAPABILITY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878400i32 as _);
pub const WHV_E_UNKNOWN_PROPERTY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878398i32 as _);
pub const WHV_E_UNSUPPORTED_HYPERVISOR_CONFIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878397i32 as _);
pub const WHV_E_UNSUPPORTED_PROCESSOR_CONFIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878384i32 as _);
pub const WHV_E_VP_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878394i32 as _);
pub const WHV_E_VP_DOES_NOT_EXIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143878393i32 as _);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct WIN32_ERROR(pub u32);
pub const NO_ERROR: WIN32_ERROR = WIN32_ERROR(0u32);
pub const WAIT_TIMEOUT: WIN32_ERROR = WIN32_ERROR(258u32);
pub const WAIT_FAILED: WIN32_ERROR = WIN32_ERROR(4294967295u32);
pub const ERROR_SUCCESS: WIN32_ERROR = WIN32_ERROR(0u32);
pub const ERROR_INVALID_FUNCTION: WIN32_ERROR = WIN32_ERROR(1u32);
pub const ERROR_FILE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(2u32);
pub const ERROR_PATH_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(3u32);
pub const ERROR_TOO_MANY_OPEN_FILES: WIN32_ERROR = WIN32_ERROR(4u32);
pub const ERROR_ACCESS_DENIED: WIN32_ERROR = WIN32_ERROR(5u32);
pub const ERROR_INVALID_HANDLE: WIN32_ERROR = WIN32_ERROR(6u32);
pub const ERROR_ARENA_TRASHED: WIN32_ERROR = WIN32_ERROR(7u32);
pub const ERROR_NOT_ENOUGH_MEMORY: WIN32_ERROR = WIN32_ERROR(8u32);
pub const ERROR_INVALID_BLOCK: WIN32_ERROR = WIN32_ERROR(9u32);
pub const ERROR_BAD_ENVIRONMENT: WIN32_ERROR = WIN32_ERROR(10u32);
pub const ERROR_BAD_FORMAT: WIN32_ERROR = WIN32_ERROR(11u32);
pub const ERROR_INVALID_ACCESS: WIN32_ERROR = WIN32_ERROR(12u32);
pub const ERROR_INVALID_DATA: WIN32_ERROR = WIN32_ERROR(13u32);
pub const ERROR_OUTOFMEMORY: WIN32_ERROR = WIN32_ERROR(14u32);
pub const ERROR_INVALID_DRIVE: WIN32_ERROR = WIN32_ERROR(15u32);
pub const ERROR_CURRENT_DIRECTORY: WIN32_ERROR = WIN32_ERROR(16u32);
pub const ERROR_NOT_SAME_DEVICE: WIN32_ERROR = WIN32_ERROR(17u32);
pub const ERROR_NO_MORE_FILES: WIN32_ERROR = WIN32_ERROR(18u32);
pub const ERROR_WRITE_PROTECT: WIN32_ERROR = WIN32_ERROR(19u32);
pub const ERROR_BAD_UNIT: WIN32_ERROR = WIN32_ERROR(20u32);
pub const ERROR_NOT_READY: WIN32_ERROR = WIN32_ERROR(21u32);
pub const ERROR_BAD_COMMAND: WIN32_ERROR = WIN32_ERROR(22u32);
pub const ERROR_CRC: WIN32_ERROR = WIN32_ERROR(23u32);
pub const ERROR_BAD_LENGTH: WIN32_ERROR = WIN32_ERROR(24u32);
pub const ERROR_SEEK: WIN32_ERROR = WIN32_ERROR(25u32);
pub const ERROR_NOT_DOS_DISK: WIN32_ERROR = WIN32_ERROR(26u32);
pub const ERROR_SECTOR_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(27u32);
pub const ERROR_OUT_OF_PAPER: WIN32_ERROR = WIN32_ERROR(28u32);
pub const ERROR_WRITE_FAULT: WIN32_ERROR = WIN32_ERROR(29u32);
pub const ERROR_READ_FAULT: WIN32_ERROR = WIN32_ERROR(30u32);
pub const ERROR_GEN_FAILURE: WIN32_ERROR = WIN32_ERROR(31u32);
pub const ERROR_SHARING_VIOLATION: WIN32_ERROR = WIN32_ERROR(32u32);
pub const ERROR_LOCK_VIOLATION: WIN32_ERROR = WIN32_ERROR(33u32);
pub const ERROR_WRONG_DISK: WIN32_ERROR = WIN32_ERROR(34u32);
pub const ERROR_SHARING_BUFFER_EXCEEDED: WIN32_ERROR = WIN32_ERROR(36u32);
pub const ERROR_HANDLE_EOF: WIN32_ERROR = WIN32_ERROR(38u32);
pub const ERROR_HANDLE_DISK_FULL: WIN32_ERROR = WIN32_ERROR(39u32);
pub const ERROR_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(50u32);
pub const ERROR_REM_NOT_LIST: WIN32_ERROR = WIN32_ERROR(51u32);
pub const ERROR_DUP_NAME: WIN32_ERROR = WIN32_ERROR(52u32);
pub const ERROR_BAD_NETPATH: WIN32_ERROR = WIN32_ERROR(53u32);
pub const ERROR_NETWORK_BUSY: WIN32_ERROR = WIN32_ERROR(54u32);
pub const ERROR_DEV_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(55u32);
pub const ERROR_TOO_MANY_CMDS: WIN32_ERROR = WIN32_ERROR(56u32);
pub const ERROR_ADAP_HDW_ERR: WIN32_ERROR = WIN32_ERROR(57u32);
pub const ERROR_BAD_NET_RESP: WIN32_ERROR = WIN32_ERROR(58u32);
pub const ERROR_UNEXP_NET_ERR: WIN32_ERROR = WIN32_ERROR(59u32);
pub const ERROR_BAD_REM_ADAP: WIN32_ERROR = WIN32_ERROR(60u32);
pub const ERROR_PRINTQ_FULL: WIN32_ERROR = WIN32_ERROR(61u32);
pub const ERROR_NO_SPOOL_SPACE: WIN32_ERROR = WIN32_ERROR(62u32);
pub const ERROR_PRINT_CANCELLED: WIN32_ERROR = WIN32_ERROR(63u32);
pub const ERROR_NETNAME_DELETED: WIN32_ERROR = WIN32_ERROR(64u32);
pub const ERROR_NETWORK_ACCESS_DENIED: WIN32_ERROR = WIN32_ERROR(65u32);
pub const ERROR_BAD_DEV_TYPE: WIN32_ERROR = WIN32_ERROR(66u32);
pub const ERROR_BAD_NET_NAME: WIN32_ERROR = WIN32_ERROR(67u32);
pub const ERROR_TOO_MANY_NAMES: WIN32_ERROR = WIN32_ERROR(68u32);
pub const ERROR_TOO_MANY_SESS: WIN32_ERROR = WIN32_ERROR(69u32);
pub const ERROR_SHARING_PAUSED: WIN32_ERROR = WIN32_ERROR(70u32);
pub const ERROR_REQ_NOT_ACCEP: WIN32_ERROR = WIN32_ERROR(71u32);
pub const ERROR_REDIR_PAUSED: WIN32_ERROR = WIN32_ERROR(72u32);
pub const ERROR_FILE_EXISTS: WIN32_ERROR = WIN32_ERROR(80u32);
pub const ERROR_CANNOT_MAKE: WIN32_ERROR = WIN32_ERROR(82u32);
pub const ERROR_FAIL_I24: WIN32_ERROR = WIN32_ERROR(83u32);
pub const ERROR_OUT_OF_STRUCTURES: WIN32_ERROR = WIN32_ERROR(84u32);
pub const ERROR_ALREADY_ASSIGNED: WIN32_ERROR = WIN32_ERROR(85u32);
pub const ERROR_INVALID_PASSWORD: WIN32_ERROR = WIN32_ERROR(86u32);
pub const ERROR_INVALID_PARAMETER: WIN32_ERROR = WIN32_ERROR(87u32);
pub const ERROR_NET_WRITE_FAULT: WIN32_ERROR = WIN32_ERROR(88u32);
pub const ERROR_NO_PROC_SLOTS: WIN32_ERROR = WIN32_ERROR(89u32);
pub const ERROR_TOO_MANY_SEMAPHORES: WIN32_ERROR = WIN32_ERROR(100u32);
pub const ERROR_EXCL_SEM_ALREADY_OWNED: WIN32_ERROR = WIN32_ERROR(101u32);
pub const ERROR_SEM_IS_SET: WIN32_ERROR = WIN32_ERROR(102u32);
pub const ERROR_TOO_MANY_SEM_REQUESTS: WIN32_ERROR = WIN32_ERROR(103u32);
pub const ERROR_INVALID_AT_INTERRUPT_TIME: WIN32_ERROR = WIN32_ERROR(104u32);
pub const ERROR_SEM_OWNER_DIED: WIN32_ERROR = WIN32_ERROR(105u32);
pub const ERROR_SEM_USER_LIMIT: WIN32_ERROR = WIN32_ERROR(106u32);
pub const ERROR_DISK_CHANGE: WIN32_ERROR = WIN32_ERROR(107u32);
pub const ERROR_DRIVE_LOCKED: WIN32_ERROR = WIN32_ERROR(108u32);
pub const ERROR_BROKEN_PIPE: WIN32_ERROR = WIN32_ERROR(109u32);
pub const ERROR_OPEN_FAILED: WIN32_ERROR = WIN32_ERROR(110u32);
pub const ERROR_BUFFER_OVERFLOW: WIN32_ERROR = WIN32_ERROR(111u32);
pub const ERROR_DISK_FULL: WIN32_ERROR = WIN32_ERROR(112u32);
pub const ERROR_NO_MORE_SEARCH_HANDLES: WIN32_ERROR = WIN32_ERROR(113u32);
pub const ERROR_INVALID_TARGET_HANDLE: WIN32_ERROR = WIN32_ERROR(114u32);
pub const ERROR_INVALID_CATEGORY: WIN32_ERROR = WIN32_ERROR(117u32);
pub const ERROR_INVALID_VERIFY_SWITCH: WIN32_ERROR = WIN32_ERROR(118u32);
pub const ERROR_BAD_DRIVER_LEVEL: WIN32_ERROR = WIN32_ERROR(119u32);
pub const ERROR_CALL_NOT_IMPLEMENTED: WIN32_ERROR = WIN32_ERROR(120u32);
pub const ERROR_SEM_TIMEOUT: WIN32_ERROR = WIN32_ERROR(121u32);
pub const ERROR_INSUFFICIENT_BUFFER: WIN32_ERROR = WIN32_ERROR(122u32);
pub const ERROR_INVALID_NAME: WIN32_ERROR = WIN32_ERROR(123u32);
pub const ERROR_INVALID_LEVEL: WIN32_ERROR = WIN32_ERROR(124u32);
pub const ERROR_NO_VOLUME_LABEL: WIN32_ERROR = WIN32_ERROR(125u32);
pub const ERROR_MOD_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(126u32);
pub const ERROR_PROC_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(127u32);
pub const ERROR_WAIT_NO_CHILDREN: WIN32_ERROR = WIN32_ERROR(128u32);
pub const ERROR_CHILD_NOT_COMPLETE: WIN32_ERROR = WIN32_ERROR(129u32);
pub const ERROR_DIRECT_ACCESS_HANDLE: WIN32_ERROR = WIN32_ERROR(130u32);
pub const ERROR_NEGATIVE_SEEK: WIN32_ERROR = WIN32_ERROR(131u32);
pub const ERROR_SEEK_ON_DEVICE: WIN32_ERROR = WIN32_ERROR(132u32);
pub const ERROR_IS_JOIN_TARGET: WIN32_ERROR = WIN32_ERROR(133u32);
pub const ERROR_IS_JOINED: WIN32_ERROR = WIN32_ERROR(134u32);
pub const ERROR_IS_SUBSTED: WIN32_ERROR = WIN32_ERROR(135u32);
pub const ERROR_NOT_JOINED: WIN32_ERROR = WIN32_ERROR(136u32);
pub const ERROR_NOT_SUBSTED: WIN32_ERROR = WIN32_ERROR(137u32);
pub const ERROR_JOIN_TO_JOIN: WIN32_ERROR = WIN32_ERROR(138u32);
pub const ERROR_SUBST_TO_SUBST: WIN32_ERROR = WIN32_ERROR(139u32);
pub const ERROR_JOIN_TO_SUBST: WIN32_ERROR = WIN32_ERROR(140u32);
pub const ERROR_SUBST_TO_JOIN: WIN32_ERROR = WIN32_ERROR(141u32);
pub const ERROR_BUSY_DRIVE: WIN32_ERROR = WIN32_ERROR(142u32);
pub const ERROR_SAME_DRIVE: WIN32_ERROR = WIN32_ERROR(143u32);
pub const ERROR_DIR_NOT_ROOT: WIN32_ERROR = WIN32_ERROR(144u32);
pub const ERROR_DIR_NOT_EMPTY: WIN32_ERROR = WIN32_ERROR(145u32);
pub const ERROR_IS_SUBST_PATH: WIN32_ERROR = WIN32_ERROR(146u32);
pub const ERROR_IS_JOIN_PATH: WIN32_ERROR = WIN32_ERROR(147u32);
pub const ERROR_PATH_BUSY: WIN32_ERROR = WIN32_ERROR(148u32);
pub const ERROR_IS_SUBST_TARGET: WIN32_ERROR = WIN32_ERROR(149u32);
pub const ERROR_SYSTEM_TRACE: WIN32_ERROR = WIN32_ERROR(150u32);
pub const ERROR_INVALID_EVENT_COUNT: WIN32_ERROR = WIN32_ERROR(151u32);
pub const ERROR_TOO_MANY_MUXWAITERS: WIN32_ERROR = WIN32_ERROR(152u32);
pub const ERROR_INVALID_LIST_FORMAT: WIN32_ERROR = WIN32_ERROR(153u32);
pub const ERROR_LABEL_TOO_LONG: WIN32_ERROR = WIN32_ERROR(154u32);
pub const ERROR_TOO_MANY_TCBS: WIN32_ERROR = WIN32_ERROR(155u32);
pub const ERROR_SIGNAL_REFUSED: WIN32_ERROR = WIN32_ERROR(156u32);
pub const ERROR_DISCARDED: WIN32_ERROR = WIN32_ERROR(157u32);
pub const ERROR_NOT_LOCKED: WIN32_ERROR = WIN32_ERROR(158u32);
pub const ERROR_BAD_THREADID_ADDR: WIN32_ERROR = WIN32_ERROR(159u32);
pub const ERROR_BAD_ARGUMENTS: WIN32_ERROR = WIN32_ERROR(160u32);
pub const ERROR_BAD_PATHNAME: WIN32_ERROR = WIN32_ERROR(161u32);
pub const ERROR_SIGNAL_PENDING: WIN32_ERROR = WIN32_ERROR(162u32);
pub const ERROR_MAX_THRDS_REACHED: WIN32_ERROR = WIN32_ERROR(164u32);
pub const ERROR_LOCK_FAILED: WIN32_ERROR = WIN32_ERROR(167u32);
pub const ERROR_BUSY: WIN32_ERROR = WIN32_ERROR(170u32);
pub const ERROR_DEVICE_SUPPORT_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(171u32);
pub const ERROR_CANCEL_VIOLATION: WIN32_ERROR = WIN32_ERROR(173u32);
pub const ERROR_ATOMIC_LOCKS_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(174u32);
pub const ERROR_INVALID_SEGMENT_NUMBER: WIN32_ERROR = WIN32_ERROR(180u32);
pub const ERROR_INVALID_ORDINAL: WIN32_ERROR = WIN32_ERROR(182u32);
pub const ERROR_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(183u32);
pub const ERROR_INVALID_FLAG_NUMBER: WIN32_ERROR = WIN32_ERROR(186u32);
pub const ERROR_SEM_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(187u32);
pub const ERROR_INVALID_STARTING_CODESEG: WIN32_ERROR = WIN32_ERROR(188u32);
pub const ERROR_INVALID_STACKSEG: WIN32_ERROR = WIN32_ERROR(189u32);
pub const ERROR_INVALID_MODULETYPE: WIN32_ERROR = WIN32_ERROR(190u32);
pub const ERROR_INVALID_EXE_SIGNATURE: WIN32_ERROR = WIN32_ERROR(191u32);
pub const ERROR_EXE_MARKED_INVALID: WIN32_ERROR = WIN32_ERROR(192u32);
pub const ERROR_BAD_EXE_FORMAT: WIN32_ERROR = WIN32_ERROR(193u32);
pub const ERROR_ITERATED_DATA_EXCEEDS_64k: WIN32_ERROR = WIN32_ERROR(194u32);
pub const ERROR_INVALID_MINALLOCSIZE: WIN32_ERROR = WIN32_ERROR(195u32);
pub const ERROR_DYNLINK_FROM_INVALID_RING: WIN32_ERROR = WIN32_ERROR(196u32);
pub const ERROR_IOPL_NOT_ENABLED: WIN32_ERROR = WIN32_ERROR(197u32);
pub const ERROR_INVALID_SEGDPL: WIN32_ERROR = WIN32_ERROR(198u32);
pub const ERROR_AUTODATASEG_EXCEEDS_64k: WIN32_ERROR = WIN32_ERROR(199u32);
pub const ERROR_RING2SEG_MUST_BE_MOVABLE: WIN32_ERROR = WIN32_ERROR(200u32);
pub const ERROR_RELOC_CHAIN_XEEDS_SEGLIM: WIN32_ERROR = WIN32_ERROR(201u32);
pub const ERROR_INFLOOP_IN_RELOC_CHAIN: WIN32_ERROR = WIN32_ERROR(202u32);
pub const ERROR_ENVVAR_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(203u32);
pub const ERROR_NO_SIGNAL_SENT: WIN32_ERROR = WIN32_ERROR(205u32);
pub const ERROR_FILENAME_EXCED_RANGE: WIN32_ERROR = WIN32_ERROR(206u32);
pub const ERROR_RING2_STACK_IN_USE: WIN32_ERROR = WIN32_ERROR(207u32);
pub const ERROR_META_EXPANSION_TOO_LONG: WIN32_ERROR = WIN32_ERROR(208u32);
pub const ERROR_INVALID_SIGNAL_NUMBER: WIN32_ERROR = WIN32_ERROR(209u32);
pub const ERROR_THREAD_1_INACTIVE: WIN32_ERROR = WIN32_ERROR(210u32);
pub const ERROR_LOCKED: WIN32_ERROR = WIN32_ERROR(212u32);
pub const ERROR_TOO_MANY_MODULES: WIN32_ERROR = WIN32_ERROR(214u32);
pub const ERROR_NESTING_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(215u32);
pub const ERROR_EXE_MACHINE_TYPE_MISMATCH: WIN32_ERROR = WIN32_ERROR(216u32);
pub const ERROR_EXE_CANNOT_MODIFY_SIGNED_BINARY: WIN32_ERROR = WIN32_ERROR(217u32);
pub const ERROR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY: WIN32_ERROR = WIN32_ERROR(218u32);
pub const ERROR_FILE_CHECKED_OUT: WIN32_ERROR = WIN32_ERROR(220u32);
pub const ERROR_CHECKOUT_REQUIRED: WIN32_ERROR = WIN32_ERROR(221u32);
pub const ERROR_BAD_FILE_TYPE: WIN32_ERROR = WIN32_ERROR(222u32);
pub const ERROR_FILE_TOO_LARGE: WIN32_ERROR = WIN32_ERROR(223u32);
pub const ERROR_FORMS_AUTH_REQUIRED: WIN32_ERROR = WIN32_ERROR(224u32);
pub const ERROR_VIRUS_INFECTED: WIN32_ERROR = WIN32_ERROR(225u32);
pub const ERROR_VIRUS_DELETED: WIN32_ERROR = WIN32_ERROR(226u32);
pub const ERROR_PIPE_LOCAL: WIN32_ERROR = WIN32_ERROR(229u32);
pub const ERROR_BAD_PIPE: WIN32_ERROR = WIN32_ERROR(230u32);
pub const ERROR_PIPE_BUSY: WIN32_ERROR = WIN32_ERROR(231u32);
pub const ERROR_NO_DATA: WIN32_ERROR = WIN32_ERROR(232u32);
pub const ERROR_PIPE_NOT_CONNECTED: WIN32_ERROR = WIN32_ERROR(233u32);
pub const ERROR_MORE_DATA: WIN32_ERROR = WIN32_ERROR(234u32);
pub const ERROR_NO_WORK_DONE: WIN32_ERROR = WIN32_ERROR(235u32);
pub const ERROR_VC_DISCONNECTED: WIN32_ERROR = WIN32_ERROR(240u32);
pub const ERROR_INVALID_EA_NAME: WIN32_ERROR = WIN32_ERROR(254u32);
pub const ERROR_EA_LIST_INCONSISTENT: WIN32_ERROR = WIN32_ERROR(255u32);
pub const ERROR_NO_MORE_ITEMS: WIN32_ERROR = WIN32_ERROR(259u32);
pub const ERROR_CANNOT_COPY: WIN32_ERROR = WIN32_ERROR(266u32);
pub const ERROR_DIRECTORY: WIN32_ERROR = WIN32_ERROR(267u32);
pub const ERROR_EAS_DIDNT_FIT: WIN32_ERROR = WIN32_ERROR(275u32);
pub const ERROR_EA_FILE_CORRUPT: WIN32_ERROR = WIN32_ERROR(276u32);
pub const ERROR_EA_TABLE_FULL: WIN32_ERROR = WIN32_ERROR(277u32);
pub const ERROR_INVALID_EA_HANDLE: WIN32_ERROR = WIN32_ERROR(278u32);
pub const ERROR_EAS_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(282u32);
pub const ERROR_NOT_OWNER: WIN32_ERROR = WIN32_ERROR(288u32);
pub const ERROR_TOO_MANY_POSTS: WIN32_ERROR = WIN32_ERROR(298u32);
pub const ERROR_PARTIAL_COPY: WIN32_ERROR = WIN32_ERROR(299u32);
pub const ERROR_OPLOCK_NOT_GRANTED: WIN32_ERROR = WIN32_ERROR(300u32);
pub const ERROR_INVALID_OPLOCK_PROTOCOL: WIN32_ERROR = WIN32_ERROR(301u32);
pub const ERROR_DISK_TOO_FRAGMENTED: WIN32_ERROR = WIN32_ERROR(302u32);
pub const ERROR_DELETE_PENDING: WIN32_ERROR = WIN32_ERROR(303u32);
pub const ERROR_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING: WIN32_ERROR = WIN32_ERROR(304u32);
pub const ERROR_SHORT_NAMES_NOT_ENABLED_ON_VOLUME: WIN32_ERROR = WIN32_ERROR(305u32);
pub const ERROR_SECURITY_STREAM_IS_INCONSISTENT: WIN32_ERROR = WIN32_ERROR(306u32);
pub const ERROR_INVALID_LOCK_RANGE: WIN32_ERROR = WIN32_ERROR(307u32);
pub const ERROR_IMAGE_SUBSYSTEM_NOT_PRESENT: WIN32_ERROR = WIN32_ERROR(308u32);
pub const ERROR_NOTIFICATION_GUID_ALREADY_DEFINED: WIN32_ERROR = WIN32_ERROR(309u32);
pub const ERROR_INVALID_EXCEPTION_HANDLER: WIN32_ERROR = WIN32_ERROR(310u32);
pub const ERROR_DUPLICATE_PRIVILEGES: WIN32_ERROR = WIN32_ERROR(311u32);
pub const ERROR_NO_RANGES_PROCESSED: WIN32_ERROR = WIN32_ERROR(312u32);
pub const ERROR_NOT_ALLOWED_ON_SYSTEM_FILE: WIN32_ERROR = WIN32_ERROR(313u32);
pub const ERROR_DISK_RESOURCES_EXHAUSTED: WIN32_ERROR = WIN32_ERROR(314u32);
pub const ERROR_INVALID_TOKEN: WIN32_ERROR = WIN32_ERROR(315u32);
pub const ERROR_DEVICE_FEATURE_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(316u32);
pub const ERROR_MR_MID_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(317u32);
pub const ERROR_SCOPE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(318u32);
pub const ERROR_UNDEFINED_SCOPE: WIN32_ERROR = WIN32_ERROR(319u32);
pub const ERROR_INVALID_CAP: WIN32_ERROR = WIN32_ERROR(320u32);
pub const ERROR_DEVICE_UNREACHABLE: WIN32_ERROR = WIN32_ERROR(321u32);
pub const ERROR_DEVICE_NO_RESOURCES: WIN32_ERROR = WIN32_ERROR(322u32);
pub const ERROR_DATA_CHECKSUM_ERROR: WIN32_ERROR = WIN32_ERROR(323u32);
pub const ERROR_INTERMIXED_KERNEL_EA_OPERATION: WIN32_ERROR = WIN32_ERROR(324u32);
pub const ERROR_FILE_LEVEL_TRIM_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(326u32);
pub const ERROR_OFFSET_ALIGNMENT_VIOLATION: WIN32_ERROR = WIN32_ERROR(327u32);
pub const ERROR_INVALID_FIELD_IN_PARAMETER_LIST: WIN32_ERROR = WIN32_ERROR(328u32);
pub const ERROR_OPERATION_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(329u32);
pub const ERROR_BAD_DEVICE_PATH: WIN32_ERROR = WIN32_ERROR(330u32);
pub const ERROR_TOO_MANY_DESCRIPTORS: WIN32_ERROR = WIN32_ERROR(331u32);
pub const ERROR_SCRUB_DATA_DISABLED: WIN32_ERROR = WIN32_ERROR(332u32);
pub const ERROR_NOT_REDUNDANT_STORAGE: WIN32_ERROR = WIN32_ERROR(333u32);
pub const ERROR_RESIDENT_FILE_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(334u32);
pub const ERROR_COMPRESSED_FILE_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(335u32);
pub const ERROR_DIRECTORY_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(336u32);
pub const ERROR_NOT_READ_FROM_COPY: WIN32_ERROR = WIN32_ERROR(337u32);
pub const ERROR_FT_WRITE_FAILURE: WIN32_ERROR = WIN32_ERROR(338u32);
pub const ERROR_FT_DI_SCAN_REQUIRED: WIN32_ERROR = WIN32_ERROR(339u32);
pub const ERROR_INVALID_KERNEL_INFO_VERSION: WIN32_ERROR = WIN32_ERROR(340u32);
pub const ERROR_INVALID_PEP_INFO_VERSION: WIN32_ERROR = WIN32_ERROR(341u32);
pub const ERROR_OBJECT_NOT_EXTERNALLY_BACKED: WIN32_ERROR = WIN32_ERROR(342u32);
pub const ERROR_EXTERNAL_BACKING_PROVIDER_UNKNOWN: WIN32_ERROR = WIN32_ERROR(343u32);
pub const ERROR_COMPRESSION_NOT_BENEFICIAL: WIN32_ERROR = WIN32_ERROR(344u32);
pub const ERROR_STORAGE_TOPOLOGY_ID_MISMATCH: WIN32_ERROR = WIN32_ERROR(345u32);
pub const ERROR_BLOCKED_BY_PARENTAL_CONTROLS: WIN32_ERROR = WIN32_ERROR(346u32);
pub const ERROR_BLOCK_TOO_MANY_REFERENCES: WIN32_ERROR = WIN32_ERROR(347u32);
pub const ERROR_MARKED_TO_DISALLOW_WRITES: WIN32_ERROR = WIN32_ERROR(348u32);
pub const ERROR_ENCLAVE_FAILURE: WIN32_ERROR = WIN32_ERROR(349u32);
pub const ERROR_FAIL_NOACTION_REBOOT: WIN32_ERROR = WIN32_ERROR(350u32);
pub const ERROR_FAIL_SHUTDOWN: WIN32_ERROR = WIN32_ERROR(351u32);
pub const ERROR_FAIL_RESTART: WIN32_ERROR = WIN32_ERROR(352u32);
pub const ERROR_MAX_SESSIONS_REACHED: WIN32_ERROR = WIN32_ERROR(353u32);
pub const ERROR_NETWORK_ACCESS_DENIED_EDP: WIN32_ERROR = WIN32_ERROR(354u32);
pub const ERROR_DEVICE_HINT_NAME_BUFFER_TOO_SMALL: WIN32_ERROR = WIN32_ERROR(355u32);
pub const ERROR_EDP_POLICY_DENIES_OPERATION: WIN32_ERROR = WIN32_ERROR(356u32);
pub const ERROR_EDP_DPL_POLICY_CANT_BE_SATISFIED: WIN32_ERROR = WIN32_ERROR(357u32);
pub const ERROR_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT: WIN32_ERROR = WIN32_ERROR(358u32);
pub const ERROR_DEVICE_IN_MAINTENANCE: WIN32_ERROR = WIN32_ERROR(359u32);
pub const ERROR_NOT_SUPPORTED_ON_DAX: WIN32_ERROR = WIN32_ERROR(360u32);
pub const ERROR_DAX_MAPPING_EXISTS: WIN32_ERROR = WIN32_ERROR(361u32);
pub const ERROR_CLOUD_FILE_PROVIDER_NOT_RUNNING: WIN32_ERROR = WIN32_ERROR(362u32);
pub const ERROR_CLOUD_FILE_METADATA_CORRUPT: WIN32_ERROR = WIN32_ERROR(363u32);
pub const ERROR_CLOUD_FILE_METADATA_TOO_LARGE: WIN32_ERROR = WIN32_ERROR(364u32);
pub const ERROR_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE: WIN32_ERROR = WIN32_ERROR(365u32);
pub const ERROR_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH: WIN32_ERROR = WIN32_ERROR(366u32);
pub const ERROR_CHILD_PROCESS_BLOCKED: WIN32_ERROR = WIN32_ERROR(367u32);
pub const ERROR_STORAGE_LOST_DATA_PERSISTENCE: WIN32_ERROR = WIN32_ERROR(368u32);
pub const ERROR_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE: WIN32_ERROR = WIN32_ERROR(369u32);
pub const ERROR_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT: WIN32_ERROR = WIN32_ERROR(370u32);
pub const ERROR_FILE_SYSTEM_VIRTUALIZATION_BUSY: WIN32_ERROR = WIN32_ERROR(371u32);
pub const ERROR_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN: WIN32_ERROR = WIN32_ERROR(372u32);
pub const ERROR_GDI_HANDLE_LEAK: WIN32_ERROR = WIN32_ERROR(373u32);
pub const ERROR_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS: WIN32_ERROR = WIN32_ERROR(374u32);
pub const ERROR_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(375u32);
pub const ERROR_NOT_A_CLOUD_FILE: WIN32_ERROR = WIN32_ERROR(376u32);
pub const ERROR_CLOUD_FILE_NOT_IN_SYNC: WIN32_ERROR = WIN32_ERROR(377u32);
pub const ERROR_CLOUD_FILE_ALREADY_CONNECTED: WIN32_ERROR = WIN32_ERROR(378u32);
pub const ERROR_CLOUD_FILE_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(379u32);
pub const ERROR_CLOUD_FILE_INVALID_REQUEST: WIN32_ERROR = WIN32_ERROR(380u32);
pub const ERROR_CLOUD_FILE_READ_ONLY_VOLUME: WIN32_ERROR = WIN32_ERROR(381u32);
pub const ERROR_CLOUD_FILE_CONNECTED_PROVIDER_ONLY: WIN32_ERROR = WIN32_ERROR(382u32);
pub const ERROR_CLOUD_FILE_VALIDATION_FAILED: WIN32_ERROR = WIN32_ERROR(383u32);
pub const ERROR_SMB1_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(384u32);
pub const ERROR_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION: WIN32_ERROR = WIN32_ERROR(385u32);
pub const ERROR_CLOUD_FILE_AUTHENTICATION_FAILED: WIN32_ERROR = WIN32_ERROR(386u32);
pub const ERROR_CLOUD_FILE_INSUFFICIENT_RESOURCES: WIN32_ERROR = WIN32_ERROR(387u32);
pub const ERROR_CLOUD_FILE_NETWORK_UNAVAILABLE: WIN32_ERROR = WIN32_ERROR(388u32);
pub const ERROR_CLOUD_FILE_UNSUCCESSFUL: WIN32_ERROR = WIN32_ERROR(389u32);
pub const ERROR_CLOUD_FILE_NOT_UNDER_SYNC_ROOT: WIN32_ERROR = WIN32_ERROR(390u32);
pub const ERROR_CLOUD_FILE_IN_USE: WIN32_ERROR = WIN32_ERROR(391u32);
pub const ERROR_CLOUD_FILE_PINNED: WIN32_ERROR = WIN32_ERROR(392u32);
pub const ERROR_CLOUD_FILE_REQUEST_ABORTED: WIN32_ERROR = WIN32_ERROR(393u32);
pub const ERROR_CLOUD_FILE_PROPERTY_CORRUPT: WIN32_ERROR = WIN32_ERROR(394u32);
pub const ERROR_CLOUD_FILE_ACCESS_DENIED: WIN32_ERROR = WIN32_ERROR(395u32);
pub const ERROR_CLOUD_FILE_INCOMPATIBLE_HARDLINKS: WIN32_ERROR = WIN32_ERROR(396u32);
pub const ERROR_CLOUD_FILE_PROPERTY_LOCK_CONFLICT: WIN32_ERROR = WIN32_ERROR(397u32);
pub const ERROR_CLOUD_FILE_REQUEST_CANCELED: WIN32_ERROR = WIN32_ERROR(398u32);
pub const ERROR_EXTERNAL_SYSKEY_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(399u32);
pub const ERROR_THREAD_MODE_ALREADY_BACKGROUND: WIN32_ERROR = WIN32_ERROR(400u32);
pub const ERROR_THREAD_MODE_NOT_BACKGROUND: WIN32_ERROR = WIN32_ERROR(401u32);
pub const ERROR_PROCESS_MODE_ALREADY_BACKGROUND: WIN32_ERROR = WIN32_ERROR(402u32);
pub const ERROR_PROCESS_MODE_NOT_BACKGROUND: WIN32_ERROR = WIN32_ERROR(403u32);
pub const ERROR_CLOUD_FILE_PROVIDER_TERMINATED: WIN32_ERROR = WIN32_ERROR(404u32);
pub const ERROR_NOT_A_CLOUD_SYNC_ROOT: WIN32_ERROR = WIN32_ERROR(405u32);
pub const ERROR_FILE_PROTECTED_UNDER_DPL: WIN32_ERROR = WIN32_ERROR(406u32);
pub const ERROR_VOLUME_NOT_CLUSTER_ALIGNED: WIN32_ERROR = WIN32_ERROR(407u32);
pub const ERROR_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND: WIN32_ERROR = WIN32_ERROR(408u32);
pub const ERROR_APPX_FILE_NOT_ENCRYPTED: WIN32_ERROR = WIN32_ERROR(409u32);
pub const ERROR_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED: WIN32_ERROR = WIN32_ERROR(410u32);
pub const ERROR_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET: WIN32_ERROR = WIN32_ERROR(411u32);
pub const ERROR_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE: WIN32_ERROR = WIN32_ERROR(412u32);
pub const ERROR_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER: WIN32_ERROR = WIN32_ERROR(413u32);
pub const ERROR_LINUX_SUBSYSTEM_NOT_PRESENT: WIN32_ERROR = WIN32_ERROR(414u32);
pub const ERROR_FT_READ_FAILURE: WIN32_ERROR = WIN32_ERROR(415u32);
pub const ERROR_STORAGE_RESERVE_ID_INVALID: WIN32_ERROR = WIN32_ERROR(416u32);
pub const ERROR_STORAGE_RESERVE_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(417u32);
pub const ERROR_STORAGE_RESERVE_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(418u32);
pub const ERROR_STORAGE_RESERVE_NOT_EMPTY: WIN32_ERROR = WIN32_ERROR(419u32);
pub const ERROR_NOT_A_DAX_VOLUME: WIN32_ERROR = WIN32_ERROR(420u32);
pub const ERROR_NOT_DAX_MAPPABLE: WIN32_ERROR = WIN32_ERROR(421u32);
pub const ERROR_TIME_SENSITIVE_THREAD: WIN32_ERROR = WIN32_ERROR(422u32);
pub const ERROR_DPL_NOT_SUPPORTED_FOR_USER: WIN32_ERROR = WIN32_ERROR(423u32);
pub const ERROR_CASE_DIFFERING_NAMES_IN_DIR: WIN32_ERROR = WIN32_ERROR(424u32);
pub const ERROR_FILE_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(425u32);
pub const ERROR_CLOUD_FILE_REQUEST_TIMEOUT: WIN32_ERROR = WIN32_ERROR(426u32);
pub const ERROR_NO_TASK_QUEUE: WIN32_ERROR = WIN32_ERROR(427u32);
pub const ERROR_SRC_SRV_DLL_LOAD_FAILED: WIN32_ERROR = WIN32_ERROR(428u32);
pub const ERROR_NOT_SUPPORTED_WITH_BTT: WIN32_ERROR = WIN32_ERROR(429u32);
pub const ERROR_ENCRYPTION_DISABLED: WIN32_ERROR = WIN32_ERROR(430u32);
pub const ERROR_ENCRYPTING_METADATA_DISALLOWED: WIN32_ERROR = WIN32_ERROR(431u32);
pub const ERROR_CANT_CLEAR_ENCRYPTION_FLAG: WIN32_ERROR = WIN32_ERROR(432u32);
pub const ERROR_NO_SUCH_DEVICE: WIN32_ERROR = WIN32_ERROR(433u32);
pub const ERROR_CLOUD_FILE_DEHYDRATION_DISALLOWED: WIN32_ERROR = WIN32_ERROR(434u32);
pub const ERROR_FILE_SNAP_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(435u32);
pub const ERROR_FILE_SNAP_USER_SECTION_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(436u32);
pub const ERROR_FILE_SNAP_MODIFY_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(437u32);
pub const ERROR_FILE_SNAP_IO_NOT_COORDINATED: WIN32_ERROR = WIN32_ERROR(438u32);
pub const ERROR_FILE_SNAP_UNEXPECTED_ERROR: WIN32_ERROR = WIN32_ERROR(439u32);
pub const ERROR_FILE_SNAP_INVALID_PARAMETER: WIN32_ERROR = WIN32_ERROR(440u32);
pub const ERROR_UNSATISFIED_DEPENDENCIES: WIN32_ERROR = WIN32_ERROR(441u32);
pub const ERROR_CASE_SENSITIVE_PATH: WIN32_ERROR = WIN32_ERROR(442u32);
pub const ERROR_UNEXPECTED_NTCACHEMANAGER_ERROR: WIN32_ERROR = WIN32_ERROR(443u32);
pub const ERROR_LINUX_SUBSYSTEM_UPDATE_REQUIRED: WIN32_ERROR = WIN32_ERROR(444u32);
pub const ERROR_DLP_POLICY_WARNS_AGAINST_OPERATION: WIN32_ERROR = WIN32_ERROR(445u32);
pub const ERROR_DLP_POLICY_DENIES_OPERATION: WIN32_ERROR = WIN32_ERROR(446u32);
pub const ERROR_SECURITY_DENIES_OPERATION: WIN32_ERROR = WIN32_ERROR(447u32);
pub const ERROR_UNTRUSTED_MOUNT_POINT: WIN32_ERROR = WIN32_ERROR(448u32);
pub const ERROR_DLP_POLICY_SILENTLY_FAIL: WIN32_ERROR = WIN32_ERROR(449u32);
pub const ERROR_CAPAUTHZ_NOT_DEVUNLOCKED: WIN32_ERROR = WIN32_ERROR(450u32);
pub const ERROR_CAPAUTHZ_CHANGE_TYPE: WIN32_ERROR = WIN32_ERROR(451u32);
pub const ERROR_CAPAUTHZ_NOT_PROVISIONED: WIN32_ERROR = WIN32_ERROR(452u32);
pub const ERROR_CAPAUTHZ_NOT_AUTHORIZED: WIN32_ERROR = WIN32_ERROR(453u32);
pub const ERROR_CAPAUTHZ_NO_POLICY: WIN32_ERROR = WIN32_ERROR(454u32);
pub const ERROR_CAPAUTHZ_DB_CORRUPTED: WIN32_ERROR = WIN32_ERROR(455u32);
pub const ERROR_CAPAUTHZ_SCCD_INVALID_CATALOG: WIN32_ERROR = WIN32_ERROR(456u32);
pub const ERROR_CAPAUTHZ_SCCD_NO_AUTH_ENTITY: WIN32_ERROR = WIN32_ERROR(457u32);
pub const ERROR_CAPAUTHZ_SCCD_PARSE_ERROR: WIN32_ERROR = WIN32_ERROR(458u32);
pub const ERROR_CAPAUTHZ_SCCD_DEV_MODE_REQUIRED: WIN32_ERROR = WIN32_ERROR(459u32);
pub const ERROR_CAPAUTHZ_SCCD_NO_CAPABILITY_MATCH: WIN32_ERROR = WIN32_ERROR(460u32);
pub const ERROR_CIMFS_IMAGE_CORRUPT: WIN32_ERROR = WIN32_ERROR(470u32);
pub const ERROR_CIMFS_IMAGE_VERSION_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(471u32);
pub const ERROR_STORAGE_STACK_ACCESS_DENIED: WIN32_ERROR = WIN32_ERROR(472u32);
pub const ERROR_INSUFFICIENT_VIRTUAL_ADDR_RESOURCES: WIN32_ERROR = WIN32_ERROR(473u32);
pub const ERROR_INDEX_OUT_OF_BOUNDS: WIN32_ERROR = WIN32_ERROR(474u32);
pub const ERROR_PNP_QUERY_REMOVE_DEVICE_TIMEOUT: WIN32_ERROR = WIN32_ERROR(480u32);
pub const ERROR_PNP_QUERY_REMOVE_RELATED_DEVICE_TIMEOUT: WIN32_ERROR = WIN32_ERROR(481u32);
pub const ERROR_PNP_QUERY_REMOVE_UNRELATED_DEVICE_TIMEOUT: WIN32_ERROR = WIN32_ERROR(482u32);
pub const ERROR_DEVICE_HARDWARE_ERROR: WIN32_ERROR = WIN32_ERROR(483u32);
pub const ERROR_INVALID_ADDRESS: WIN32_ERROR = WIN32_ERROR(487u32);
pub const ERROR_HAS_SYSTEM_CRITICAL_FILES: WIN32_ERROR = WIN32_ERROR(488u32);
pub const ERROR_ENCRYPTED_FILE_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(489u32);
pub const ERROR_SPARSE_FILE_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(490u32);
pub const ERROR_PAGEFILE_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(491u32);
pub const ERROR_VOLUME_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(492u32);
pub const ERROR_NOT_SUPPORTED_WITH_BYPASSIO: WIN32_ERROR = WIN32_ERROR(493u32);
pub const ERROR_NO_BYPASSIO_DRIVER_SUPPORT: WIN32_ERROR = WIN32_ERROR(494u32);
pub const ERROR_NOT_SUPPORTED_WITH_ENCRYPTION: WIN32_ERROR = WIN32_ERROR(495u32);
pub const ERROR_NOT_SUPPORTED_WITH_COMPRESSION: WIN32_ERROR = WIN32_ERROR(496u32);
pub const ERROR_NOT_SUPPORTED_WITH_REPLICATION: WIN32_ERROR = WIN32_ERROR(497u32);
pub const ERROR_NOT_SUPPORTED_WITH_DEDUPLICATION: WIN32_ERROR = WIN32_ERROR(498u32);
pub const ERROR_NOT_SUPPORTED_WITH_AUDITING: WIN32_ERROR = WIN32_ERROR(499u32);
pub const ERROR_USER_PROFILE_LOAD: WIN32_ERROR = WIN32_ERROR(500u32);
pub const ERROR_SESSION_KEY_TOO_SHORT: WIN32_ERROR = WIN32_ERROR(501u32);
pub const ERROR_ACCESS_DENIED_APPDATA: WIN32_ERROR = WIN32_ERROR(502u32);
pub const ERROR_NOT_SUPPORTED_WITH_MONITORING: WIN32_ERROR = WIN32_ERROR(503u32);
pub const ERROR_NOT_SUPPORTED_WITH_SNAPSHOT: WIN32_ERROR = WIN32_ERROR(504u32);
pub const ERROR_NOT_SUPPORTED_WITH_VIRTUALIZATION: WIN32_ERROR = WIN32_ERROR(505u32);
pub const ERROR_BYPASSIO_FLT_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(506u32);
pub const ERROR_DEVICE_RESET_REQUIRED: WIN32_ERROR = WIN32_ERROR(507u32);
pub const ERROR_VOLUME_WRITE_ACCESS_DENIED: WIN32_ERROR = WIN32_ERROR(508u32);
pub const ERROR_ARITHMETIC_OVERFLOW: WIN32_ERROR = WIN32_ERROR(534u32);
pub const ERROR_PIPE_CONNECTED: WIN32_ERROR = WIN32_ERROR(535u32);
pub const ERROR_PIPE_LISTENING: WIN32_ERROR = WIN32_ERROR(536u32);
pub const ERROR_VERIFIER_STOP: WIN32_ERROR = WIN32_ERROR(537u32);
pub const ERROR_ABIOS_ERROR: WIN32_ERROR = WIN32_ERROR(538u32);
pub const ERROR_WX86_WARNING: WIN32_ERROR = WIN32_ERROR(539u32);
pub const ERROR_WX86_ERROR: WIN32_ERROR = WIN32_ERROR(540u32);
pub const ERROR_TIMER_NOT_CANCELED: WIN32_ERROR = WIN32_ERROR(541u32);
pub const ERROR_UNWIND: WIN32_ERROR = WIN32_ERROR(542u32);
pub const ERROR_BAD_STACK: WIN32_ERROR = WIN32_ERROR(543u32);
pub const ERROR_INVALID_UNWIND_TARGET: WIN32_ERROR = WIN32_ERROR(544u32);
pub const ERROR_INVALID_PORT_ATTRIBUTES: WIN32_ERROR = WIN32_ERROR(545u32);
pub const ERROR_PORT_MESSAGE_TOO_LONG: WIN32_ERROR = WIN32_ERROR(546u32);
pub const ERROR_INVALID_QUOTA_LOWER: WIN32_ERROR = WIN32_ERROR(547u32);
pub const ERROR_DEVICE_ALREADY_ATTACHED: WIN32_ERROR = WIN32_ERROR(548u32);
pub const ERROR_INSTRUCTION_MISALIGNMENT: WIN32_ERROR = WIN32_ERROR(549u32);
pub const ERROR_PROFILING_NOT_STARTED: WIN32_ERROR = WIN32_ERROR(550u32);
pub const ERROR_PROFILING_NOT_STOPPED: WIN32_ERROR = WIN32_ERROR(551u32);
pub const ERROR_COULD_NOT_INTERPRET: WIN32_ERROR = WIN32_ERROR(552u32);
pub const ERROR_PROFILING_AT_LIMIT: WIN32_ERROR = WIN32_ERROR(553u32);
pub const ERROR_CANT_WAIT: WIN32_ERROR = WIN32_ERROR(554u32);
pub const ERROR_CANT_TERMINATE_SELF: WIN32_ERROR = WIN32_ERROR(555u32);
pub const ERROR_UNEXPECTED_MM_CREATE_ERR: WIN32_ERROR = WIN32_ERROR(556u32);
pub const ERROR_UNEXPECTED_MM_MAP_ERROR: WIN32_ERROR = WIN32_ERROR(557u32);
pub const ERROR_UNEXPECTED_MM_EXTEND_ERR: WIN32_ERROR = WIN32_ERROR(558u32);
pub const ERROR_BAD_FUNCTION_TABLE: WIN32_ERROR = WIN32_ERROR(559u32);
pub const ERROR_NO_GUID_TRANSLATION: WIN32_ERROR = WIN32_ERROR(560u32);
pub const ERROR_INVALID_LDT_SIZE: WIN32_ERROR = WIN32_ERROR(561u32);
pub const ERROR_INVALID_LDT_OFFSET: WIN32_ERROR = WIN32_ERROR(563u32);
pub const ERROR_INVALID_LDT_DESCRIPTOR: WIN32_ERROR = WIN32_ERROR(564u32);
pub const ERROR_TOO_MANY_THREADS: WIN32_ERROR = WIN32_ERROR(565u32);
pub const ERROR_THREAD_NOT_IN_PROCESS: WIN32_ERROR = WIN32_ERROR(566u32);
pub const ERROR_PAGEFILE_QUOTA_EXCEEDED: WIN32_ERROR = WIN32_ERROR(567u32);
pub const ERROR_LOGON_SERVER_CONFLICT: WIN32_ERROR = WIN32_ERROR(568u32);
pub const ERROR_SYNCHRONIZATION_REQUIRED: WIN32_ERROR = WIN32_ERROR(569u32);
pub const ERROR_NET_OPEN_FAILED: WIN32_ERROR = WIN32_ERROR(570u32);
pub const ERROR_IO_PRIVILEGE_FAILED: WIN32_ERROR = WIN32_ERROR(571u32);
pub const ERROR_CONTROL_C_EXIT: WIN32_ERROR = WIN32_ERROR(572u32);
pub const ERROR_MISSING_SYSTEMFILE: WIN32_ERROR = WIN32_ERROR(573u32);
pub const ERROR_UNHANDLED_EXCEPTION: WIN32_ERROR = WIN32_ERROR(574u32);
pub const ERROR_APP_INIT_FAILURE: WIN32_ERROR = WIN32_ERROR(575u32);
pub const ERROR_PAGEFILE_CREATE_FAILED: WIN32_ERROR = WIN32_ERROR(576u32);
pub const ERROR_INVALID_IMAGE_HASH: WIN32_ERROR = WIN32_ERROR(577u32);
pub const ERROR_NO_PAGEFILE: WIN32_ERROR = WIN32_ERROR(578u32);
pub const ERROR_ILLEGAL_FLOAT_CONTEXT: WIN32_ERROR = WIN32_ERROR(579u32);
pub const ERROR_NO_EVENT_PAIR: WIN32_ERROR = WIN32_ERROR(580u32);
pub const ERROR_DOMAIN_CTRLR_CONFIG_ERROR: WIN32_ERROR = WIN32_ERROR(581u32);
pub const ERROR_ILLEGAL_CHARACTER: WIN32_ERROR = WIN32_ERROR(582u32);
pub const ERROR_UNDEFINED_CHARACTER: WIN32_ERROR = WIN32_ERROR(583u32);
pub const ERROR_FLOPPY_VOLUME: WIN32_ERROR = WIN32_ERROR(584u32);
pub const ERROR_BIOS_FAILED_TO_CONNECT_INTERRUPT: WIN32_ERROR = WIN32_ERROR(585u32);
pub const ERROR_BACKUP_CONTROLLER: WIN32_ERROR = WIN32_ERROR(586u32);
pub const ERROR_MUTANT_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(587u32);
pub const ERROR_FS_DRIVER_REQUIRED: WIN32_ERROR = WIN32_ERROR(588u32);
pub const ERROR_CANNOT_LOAD_REGISTRY_FILE: WIN32_ERROR = WIN32_ERROR(589u32);
pub const ERROR_DEBUG_ATTACH_FAILED: WIN32_ERROR = WIN32_ERROR(590u32);
pub const ERROR_SYSTEM_PROCESS_TERMINATED: WIN32_ERROR = WIN32_ERROR(591u32);
pub const ERROR_DATA_NOT_ACCEPTED: WIN32_ERROR = WIN32_ERROR(592u32);
pub const ERROR_VDM_HARD_ERROR: WIN32_ERROR = WIN32_ERROR(593u32);
pub const ERROR_DRIVER_CANCEL_TIMEOUT: WIN32_ERROR = WIN32_ERROR(594u32);
pub const ERROR_REPLY_MESSAGE_MISMATCH: WIN32_ERROR = WIN32_ERROR(595u32);
pub const ERROR_LOST_WRITEBEHIND_DATA: WIN32_ERROR = WIN32_ERROR(596u32);
pub const ERROR_CLIENT_SERVER_PARAMETERS_INVALID: WIN32_ERROR = WIN32_ERROR(597u32);
pub const ERROR_NOT_TINY_STREAM: WIN32_ERROR = WIN32_ERROR(598u32);
pub const ERROR_STACK_OVERFLOW_READ: WIN32_ERROR = WIN32_ERROR(599u32);
pub const ERROR_CONVERT_TO_LARGE: WIN32_ERROR = WIN32_ERROR(600u32);
pub const ERROR_FOUND_OUT_OF_SCOPE: WIN32_ERROR = WIN32_ERROR(601u32);
pub const ERROR_ALLOCATE_BUCKET: WIN32_ERROR = WIN32_ERROR(602u32);
pub const ERROR_MARSHALL_OVERFLOW: WIN32_ERROR = WIN32_ERROR(603u32);
pub const ERROR_INVALID_VARIANT: WIN32_ERROR = WIN32_ERROR(604u32);
pub const ERROR_BAD_COMPRESSION_BUFFER: WIN32_ERROR = WIN32_ERROR(605u32);
pub const ERROR_AUDIT_FAILED: WIN32_ERROR = WIN32_ERROR(606u32);
pub const ERROR_TIMER_RESOLUTION_NOT_SET: WIN32_ERROR = WIN32_ERROR(607u32);
pub const ERROR_INSUFFICIENT_LOGON_INFO: WIN32_ERROR = WIN32_ERROR(608u32);
pub const ERROR_BAD_DLL_ENTRYPOINT: WIN32_ERROR = WIN32_ERROR(609u32);
pub const ERROR_BAD_SERVICE_ENTRYPOINT: WIN32_ERROR = WIN32_ERROR(610u32);
pub const ERROR_IP_ADDRESS_CONFLICT1: WIN32_ERROR = WIN32_ERROR(611u32);
pub const ERROR_IP_ADDRESS_CONFLICT2: WIN32_ERROR = WIN32_ERROR(612u32);
pub const ERROR_REGISTRY_QUOTA_LIMIT: WIN32_ERROR = WIN32_ERROR(613u32);
pub const ERROR_NO_CALLBACK_ACTIVE: WIN32_ERROR = WIN32_ERROR(614u32);
pub const ERROR_PWD_TOO_SHORT: WIN32_ERROR = WIN32_ERROR(615u32);
pub const ERROR_PWD_TOO_RECENT: WIN32_ERROR = WIN32_ERROR(616u32);
pub const ERROR_PWD_HISTORY_CONFLICT: WIN32_ERROR = WIN32_ERROR(617u32);
pub const ERROR_UNSUPPORTED_COMPRESSION: WIN32_ERROR = WIN32_ERROR(618u32);
pub const ERROR_INVALID_HW_PROFILE: WIN32_ERROR = WIN32_ERROR(619u32);
pub const ERROR_INVALID_PLUGPLAY_DEVICE_PATH: WIN32_ERROR = WIN32_ERROR(620u32);
pub const ERROR_QUOTA_LIST_INCONSISTENT: WIN32_ERROR = WIN32_ERROR(621u32);
pub const ERROR_EVALUATION_EXPIRATION: WIN32_ERROR = WIN32_ERROR(622u32);
pub const ERROR_ILLEGAL_DLL_RELOCATION: WIN32_ERROR = WIN32_ERROR(623u32);
pub const ERROR_DLL_INIT_FAILED_LOGOFF: WIN32_ERROR = WIN32_ERROR(624u32);
pub const ERROR_VALIDATE_CONTINUE: WIN32_ERROR = WIN32_ERROR(625u32);
pub const ERROR_NO_MORE_MATCHES: WIN32_ERROR = WIN32_ERROR(626u32);
pub const ERROR_RANGE_LIST_CONFLICT: WIN32_ERROR = WIN32_ERROR(627u32);
pub const ERROR_SERVER_SID_MISMATCH: WIN32_ERROR = WIN32_ERROR(628u32);
pub const ERROR_CANT_ENABLE_DENY_ONLY: WIN32_ERROR = WIN32_ERROR(629u32);
pub const ERROR_FLOAT_MULTIPLE_FAULTS: WIN32_ERROR = WIN32_ERROR(630u32);
pub const ERROR_FLOAT_MULTIPLE_TRAPS: WIN32_ERROR = WIN32_ERROR(631u32);
pub const ERROR_NOINTERFACE: WIN32_ERROR = WIN32_ERROR(632u32);
pub const ERROR_DRIVER_FAILED_SLEEP: WIN32_ERROR = WIN32_ERROR(633u32);
pub const ERROR_CORRUPT_SYSTEM_FILE: WIN32_ERROR = WIN32_ERROR(634u32);
pub const ERROR_COMMITMENT_MINIMUM: WIN32_ERROR = WIN32_ERROR(635u32);
pub const ERROR_PNP_RESTART_ENUMERATION: WIN32_ERROR = WIN32_ERROR(636u32);
pub const ERROR_SYSTEM_IMAGE_BAD_SIGNATURE: WIN32_ERROR = WIN32_ERROR(637u32);
pub const ERROR_PNP_REBOOT_REQUIRED: WIN32_ERROR = WIN32_ERROR(638u32);
pub const ERROR_INSUFFICIENT_POWER: WIN32_ERROR = WIN32_ERROR(639u32);
pub const ERROR_MULTIPLE_FAULT_VIOLATION: WIN32_ERROR = WIN32_ERROR(640u32);
pub const ERROR_SYSTEM_SHUTDOWN: WIN32_ERROR = WIN32_ERROR(641u32);
pub const ERROR_PORT_NOT_SET: WIN32_ERROR = WIN32_ERROR(642u32);
pub const ERROR_DS_VERSION_CHECK_FAILURE: WIN32_ERROR = WIN32_ERROR(643u32);
pub const ERROR_RANGE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(644u32);
pub const ERROR_NOT_SAFE_MODE_DRIVER: WIN32_ERROR = WIN32_ERROR(646u32);
pub const ERROR_FAILED_DRIVER_ENTRY: WIN32_ERROR = WIN32_ERROR(647u32);
pub const ERROR_DEVICE_ENUMERATION_ERROR: WIN32_ERROR = WIN32_ERROR(648u32);
pub const ERROR_MOUNT_POINT_NOT_RESOLVED: WIN32_ERROR = WIN32_ERROR(649u32);
pub const ERROR_INVALID_DEVICE_OBJECT_PARAMETER: WIN32_ERROR = WIN32_ERROR(650u32);
pub const ERROR_MCA_OCCURED: WIN32_ERROR = WIN32_ERROR(651u32);
pub const ERROR_DRIVER_DATABASE_ERROR: WIN32_ERROR = WIN32_ERROR(652u32);
pub const ERROR_SYSTEM_HIVE_TOO_LARGE: WIN32_ERROR = WIN32_ERROR(653u32);
pub const ERROR_DRIVER_FAILED_PRIOR_UNLOAD: WIN32_ERROR = WIN32_ERROR(654u32);
pub const ERROR_VOLSNAP_PREPARE_HIBERNATE: WIN32_ERROR = WIN32_ERROR(655u32);
pub const ERROR_HIBERNATION_FAILURE: WIN32_ERROR = WIN32_ERROR(656u32);
pub const ERROR_PWD_TOO_LONG: WIN32_ERROR = WIN32_ERROR(657u32);
pub const ERROR_FILE_SYSTEM_LIMITATION: WIN32_ERROR = WIN32_ERROR(665u32);
pub const ERROR_ASSERTION_FAILURE: WIN32_ERROR = WIN32_ERROR(668u32);
pub const ERROR_ACPI_ERROR: WIN32_ERROR = WIN32_ERROR(669u32);
pub const ERROR_WOW_ASSERTION: WIN32_ERROR = WIN32_ERROR(670u32);
pub const ERROR_PNP_BAD_MPS_TABLE: WIN32_ERROR = WIN32_ERROR(671u32);
pub const ERROR_PNP_TRANSLATION_FAILED: WIN32_ERROR = WIN32_ERROR(672u32);
pub const ERROR_PNP_IRQ_TRANSLATION_FAILED: WIN32_ERROR = WIN32_ERROR(673u32);
pub const ERROR_PNP_INVALID_ID: WIN32_ERROR = WIN32_ERROR(674u32);
pub const ERROR_WAKE_SYSTEM_DEBUGGER: WIN32_ERROR = WIN32_ERROR(675u32);
pub const ERROR_HANDLES_CLOSED: WIN32_ERROR = WIN32_ERROR(676u32);
pub const ERROR_EXTRANEOUS_INFORMATION: WIN32_ERROR = WIN32_ERROR(677u32);
pub const ERROR_RXACT_COMMIT_NECESSARY: WIN32_ERROR = WIN32_ERROR(678u32);
pub const ERROR_MEDIA_CHECK: WIN32_ERROR = WIN32_ERROR(679u32);
pub const ERROR_GUID_SUBSTITUTION_MADE: WIN32_ERROR = WIN32_ERROR(680u32);
pub const ERROR_STOPPED_ON_SYMLINK: WIN32_ERROR = WIN32_ERROR(681u32);
pub const ERROR_LONGJUMP: WIN32_ERROR = WIN32_ERROR(682u32);
pub const ERROR_PLUGPLAY_QUERY_VETOED: WIN32_ERROR = WIN32_ERROR(683u32);
pub const ERROR_UNWIND_CONSOLIDATE: WIN32_ERROR = WIN32_ERROR(684u32);
pub const ERROR_REGISTRY_HIVE_RECOVERED: WIN32_ERROR = WIN32_ERROR(685u32);
pub const ERROR_DLL_MIGHT_BE_INSECURE: WIN32_ERROR = WIN32_ERROR(686u32);
pub const ERROR_DLL_MIGHT_BE_INCOMPATIBLE: WIN32_ERROR = WIN32_ERROR(687u32);
pub const ERROR_DBG_EXCEPTION_NOT_HANDLED: WIN32_ERROR = WIN32_ERROR(688u32);
pub const ERROR_DBG_REPLY_LATER: WIN32_ERROR = WIN32_ERROR(689u32);
pub const ERROR_DBG_UNABLE_TO_PROVIDE_HANDLE: WIN32_ERROR = WIN32_ERROR(690u32);
pub const ERROR_DBG_TERMINATE_THREAD: WIN32_ERROR = WIN32_ERROR(691u32);
pub const ERROR_DBG_TERMINATE_PROCESS: WIN32_ERROR = WIN32_ERROR(692u32);
pub const ERROR_DBG_CONTROL_C: WIN32_ERROR = WIN32_ERROR(693u32);
pub const ERROR_DBG_PRINTEXCEPTION_C: WIN32_ERROR = WIN32_ERROR(694u32);
pub const ERROR_DBG_RIPEXCEPTION: WIN32_ERROR = WIN32_ERROR(695u32);
pub const ERROR_DBG_CONTROL_BREAK: WIN32_ERROR = WIN32_ERROR(696u32);
pub const ERROR_DBG_COMMAND_EXCEPTION: WIN32_ERROR = WIN32_ERROR(697u32);
pub const ERROR_OBJECT_NAME_EXISTS: WIN32_ERROR = WIN32_ERROR(698u32);
pub const ERROR_THREAD_WAS_SUSPENDED: WIN32_ERROR = WIN32_ERROR(699u32);
pub const ERROR_IMAGE_NOT_AT_BASE: WIN32_ERROR = WIN32_ERROR(700u32);
pub const ERROR_RXACT_STATE_CREATED: WIN32_ERROR = WIN32_ERROR(701u32);
pub const ERROR_SEGMENT_NOTIFICATION: WIN32_ERROR = WIN32_ERROR(702u32);
pub const ERROR_BAD_CURRENT_DIRECTORY: WIN32_ERROR = WIN32_ERROR(703u32);
pub const ERROR_FT_READ_RECOVERY_FROM_BACKUP: WIN32_ERROR = WIN32_ERROR(704u32);
pub const ERROR_FT_WRITE_RECOVERY: WIN32_ERROR = WIN32_ERROR(705u32);
pub const ERROR_IMAGE_MACHINE_TYPE_MISMATCH: WIN32_ERROR = WIN32_ERROR(706u32);
pub const ERROR_RECEIVE_PARTIAL: WIN32_ERROR = WIN32_ERROR(707u32);
pub const ERROR_RECEIVE_EXPEDITED: WIN32_ERROR = WIN32_ERROR(708u32);
pub const ERROR_RECEIVE_PARTIAL_EXPEDITED: WIN32_ERROR = WIN32_ERROR(709u32);
pub const ERROR_EVENT_DONE: WIN32_ERROR = WIN32_ERROR(710u32);
pub const ERROR_EVENT_PENDING: WIN32_ERROR = WIN32_ERROR(711u32);
pub const ERROR_CHECKING_FILE_SYSTEM: WIN32_ERROR = WIN32_ERROR(712u32);
pub const ERROR_FATAL_APP_EXIT: WIN32_ERROR = WIN32_ERROR(713u32);
pub const ERROR_PREDEFINED_HANDLE: WIN32_ERROR = WIN32_ERROR(714u32);
pub const ERROR_WAS_UNLOCKED: WIN32_ERROR = WIN32_ERROR(715u32);
pub const ERROR_SERVICE_NOTIFICATION: WIN32_ERROR = WIN32_ERROR(716u32);
pub const ERROR_WAS_LOCKED: WIN32_ERROR = WIN32_ERROR(717u32);
pub const ERROR_LOG_HARD_ERROR: WIN32_ERROR = WIN32_ERROR(718u32);
pub const ERROR_ALREADY_WIN32: WIN32_ERROR = WIN32_ERROR(719u32);
pub const ERROR_IMAGE_MACHINE_TYPE_MISMATCH_EXE: WIN32_ERROR = WIN32_ERROR(720u32);
pub const ERROR_NO_YIELD_PERFORMED: WIN32_ERROR = WIN32_ERROR(721u32);
pub const ERROR_TIMER_RESUME_IGNORED: WIN32_ERROR = WIN32_ERROR(722u32);
pub const ERROR_ARBITRATION_UNHANDLED: WIN32_ERROR = WIN32_ERROR(723u32);
pub const ERROR_CARDBUS_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(724u32);
pub const ERROR_MP_PROCESSOR_MISMATCH: WIN32_ERROR = WIN32_ERROR(725u32);
pub const ERROR_HIBERNATED: WIN32_ERROR = WIN32_ERROR(726u32);
pub const ERROR_RESUME_HIBERNATION: WIN32_ERROR = WIN32_ERROR(727u32);
pub const ERROR_FIRMWARE_UPDATED: WIN32_ERROR = WIN32_ERROR(728u32);
pub const ERROR_DRIVERS_LEAKING_LOCKED_PAGES: WIN32_ERROR = WIN32_ERROR(729u32);
pub const ERROR_WAKE_SYSTEM: WIN32_ERROR = WIN32_ERROR(730u32);
pub const ERROR_WAIT_1: WIN32_ERROR = WIN32_ERROR(731u32);
pub const ERROR_WAIT_2: WIN32_ERROR = WIN32_ERROR(732u32);
pub const ERROR_WAIT_3: WIN32_ERROR = WIN32_ERROR(733u32);
pub const ERROR_WAIT_63: WIN32_ERROR = WIN32_ERROR(734u32);
pub const ERROR_ABANDONED_WAIT_0: WIN32_ERROR = WIN32_ERROR(735u32);
pub const ERROR_ABANDONED_WAIT_63: WIN32_ERROR = WIN32_ERROR(736u32);
pub const ERROR_USER_APC: WIN32_ERROR = WIN32_ERROR(737u32);
pub const ERROR_KERNEL_APC: WIN32_ERROR = WIN32_ERROR(738u32);
pub const ERROR_ALERTED: WIN32_ERROR = WIN32_ERROR(739u32);
pub const ERROR_ELEVATION_REQUIRED: WIN32_ERROR = WIN32_ERROR(740u32);
pub const ERROR_REPARSE: WIN32_ERROR = WIN32_ERROR(741u32);
pub const ERROR_OPLOCK_BREAK_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(742u32);
pub const ERROR_VOLUME_MOUNTED: WIN32_ERROR = WIN32_ERROR(743u32);
pub const ERROR_RXACT_COMMITTED: WIN32_ERROR = WIN32_ERROR(744u32);
pub const ERROR_NOTIFY_CLEANUP: WIN32_ERROR = WIN32_ERROR(745u32);
pub const ERROR_PRIMARY_TRANSPORT_CONNECT_FAILED: WIN32_ERROR = WIN32_ERROR(746u32);
pub const ERROR_PAGE_FAULT_TRANSITION: WIN32_ERROR = WIN32_ERROR(747u32);
pub const ERROR_PAGE_FAULT_DEMAND_ZERO: WIN32_ERROR = WIN32_ERROR(748u32);
pub const ERROR_PAGE_FAULT_COPY_ON_WRITE: WIN32_ERROR = WIN32_ERROR(749u32);
pub const ERROR_PAGE_FAULT_GUARD_PAGE: WIN32_ERROR = WIN32_ERROR(750u32);
pub const ERROR_PAGE_FAULT_PAGING_FILE: WIN32_ERROR = WIN32_ERROR(751u32);
pub const ERROR_CACHE_PAGE_LOCKED: WIN32_ERROR = WIN32_ERROR(752u32);
pub const ERROR_CRASH_DUMP: WIN32_ERROR = WIN32_ERROR(753u32);
pub const ERROR_BUFFER_ALL_ZEROS: WIN32_ERROR = WIN32_ERROR(754u32);
pub const ERROR_REPARSE_OBJECT: WIN32_ERROR = WIN32_ERROR(755u32);
pub const ERROR_RESOURCE_REQUIREMENTS_CHANGED: WIN32_ERROR = WIN32_ERROR(756u32);
pub const ERROR_TRANSLATION_COMPLETE: WIN32_ERROR = WIN32_ERROR(757u32);
pub const ERROR_NOTHING_TO_TERMINATE: WIN32_ERROR = WIN32_ERROR(758u32);
pub const ERROR_PROCESS_NOT_IN_JOB: WIN32_ERROR = WIN32_ERROR(759u32);
pub const ERROR_PROCESS_IN_JOB: WIN32_ERROR = WIN32_ERROR(760u32);
pub const ERROR_VOLSNAP_HIBERNATE_READY: WIN32_ERROR = WIN32_ERROR(761u32);
pub const ERROR_FSFILTER_OP_COMPLETED_SUCCESSFULLY: WIN32_ERROR = WIN32_ERROR(762u32);
pub const ERROR_INTERRUPT_VECTOR_ALREADY_CONNECTED: WIN32_ERROR = WIN32_ERROR(763u32);
pub const ERROR_INTERRUPT_STILL_CONNECTED: WIN32_ERROR = WIN32_ERROR(764u32);
pub const ERROR_WAIT_FOR_OPLOCK: WIN32_ERROR = WIN32_ERROR(765u32);
pub const ERROR_DBG_EXCEPTION_HANDLED: WIN32_ERROR = WIN32_ERROR(766u32);
pub const ERROR_DBG_CONTINUE: WIN32_ERROR = WIN32_ERROR(767u32);
pub const ERROR_CALLBACK_POP_STACK: WIN32_ERROR = WIN32_ERROR(768u32);
pub const ERROR_COMPRESSION_DISABLED: WIN32_ERROR = WIN32_ERROR(769u32);
pub const ERROR_CANTFETCHBACKWARDS: WIN32_ERROR = WIN32_ERROR(770u32);
pub const ERROR_CANTSCROLLBACKWARDS: WIN32_ERROR = WIN32_ERROR(771u32);
pub const ERROR_ROWSNOTRELEASED: WIN32_ERROR = WIN32_ERROR(772u32);
pub const ERROR_BAD_ACCESSOR_FLAGS: WIN32_ERROR = WIN32_ERROR(773u32);
pub const ERROR_ERRORS_ENCOUNTERED: WIN32_ERROR = WIN32_ERROR(774u32);
pub const ERROR_NOT_CAPABLE: WIN32_ERROR = WIN32_ERROR(775u32);
pub const ERROR_REQUEST_OUT_OF_SEQUENCE: WIN32_ERROR = WIN32_ERROR(776u32);
pub const ERROR_VERSION_PARSE_ERROR: WIN32_ERROR = WIN32_ERROR(777u32);
pub const ERROR_BADSTARTPOSITION: WIN32_ERROR = WIN32_ERROR(778u32);
pub const ERROR_MEMORY_HARDWARE: WIN32_ERROR = WIN32_ERROR(779u32);
pub const ERROR_DISK_REPAIR_DISABLED: WIN32_ERROR = WIN32_ERROR(780u32);
pub const ERROR_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE: WIN32_ERROR = WIN32_ERROR(781u32);
pub const ERROR_SYSTEM_POWERSTATE_TRANSITION: WIN32_ERROR = WIN32_ERROR(782u32);
pub const ERROR_SYSTEM_POWERSTATE_COMPLEX_TRANSITION: WIN32_ERROR = WIN32_ERROR(783u32);
pub const ERROR_MCA_EXCEPTION: WIN32_ERROR = WIN32_ERROR(784u32);
pub const ERROR_ACCESS_AUDIT_BY_POLICY: WIN32_ERROR = WIN32_ERROR(785u32);
pub const ERROR_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY: WIN32_ERROR = WIN32_ERROR(786u32);
pub const ERROR_ABANDON_HIBERFILE: WIN32_ERROR = WIN32_ERROR(787u32);
pub const ERROR_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED: WIN32_ERROR = WIN32_ERROR(788u32);
pub const ERROR_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR: WIN32_ERROR = WIN32_ERROR(789u32);
pub const ERROR_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR: WIN32_ERROR = WIN32_ERROR(790u32);
pub const ERROR_BAD_MCFG_TABLE: WIN32_ERROR = WIN32_ERROR(791u32);
pub const ERROR_DISK_REPAIR_REDIRECTED: WIN32_ERROR = WIN32_ERROR(792u32);
pub const ERROR_DISK_REPAIR_UNSUCCESSFUL: WIN32_ERROR = WIN32_ERROR(793u32);
pub const ERROR_CORRUPT_LOG_OVERFULL: WIN32_ERROR = WIN32_ERROR(794u32);
pub const ERROR_CORRUPT_LOG_CORRUPTED: WIN32_ERROR = WIN32_ERROR(795u32);
pub const ERROR_CORRUPT_LOG_UNAVAILABLE: WIN32_ERROR = WIN32_ERROR(796u32);
pub const ERROR_CORRUPT_LOG_DELETED_FULL: WIN32_ERROR = WIN32_ERROR(797u32);
pub const ERROR_CORRUPT_LOG_CLEARED: WIN32_ERROR = WIN32_ERROR(798u32);
pub const ERROR_ORPHAN_NAME_EXHAUSTED: WIN32_ERROR = WIN32_ERROR(799u32);
pub const ERROR_OPLOCK_SWITCHED_TO_NEW_HANDLE: WIN32_ERROR = WIN32_ERROR(800u32);
pub const ERROR_CANNOT_GRANT_REQUESTED_OPLOCK: WIN32_ERROR = WIN32_ERROR(801u32);
pub const ERROR_CANNOT_BREAK_OPLOCK: WIN32_ERROR = WIN32_ERROR(802u32);
pub const ERROR_OPLOCK_HANDLE_CLOSED: WIN32_ERROR = WIN32_ERROR(803u32);
pub const ERROR_NO_ACE_CONDITION: WIN32_ERROR = WIN32_ERROR(804u32);
pub const ERROR_INVALID_ACE_CONDITION: WIN32_ERROR = WIN32_ERROR(805u32);
pub const ERROR_FILE_HANDLE_REVOKED: WIN32_ERROR = WIN32_ERROR(806u32);
pub const ERROR_IMAGE_AT_DIFFERENT_BASE: WIN32_ERROR = WIN32_ERROR(807u32);
pub const ERROR_ENCRYPTED_IO_NOT_POSSIBLE: WIN32_ERROR = WIN32_ERROR(808u32);
pub const ERROR_FILE_METADATA_OPTIMIZATION_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(809u32);
pub const ERROR_QUOTA_ACTIVITY: WIN32_ERROR = WIN32_ERROR(810u32);
pub const ERROR_HANDLE_REVOKED: WIN32_ERROR = WIN32_ERROR(811u32);
pub const ERROR_CALLBACK_INVOKE_INLINE: WIN32_ERROR = WIN32_ERROR(812u32);
pub const ERROR_CPU_SET_INVALID: WIN32_ERROR = WIN32_ERROR(813u32);
pub const ERROR_ENCLAVE_NOT_TERMINATED: WIN32_ERROR = WIN32_ERROR(814u32);
pub const ERROR_ENCLAVE_VIOLATION: WIN32_ERROR = WIN32_ERROR(815u32);
pub const ERROR_SERVER_TRANSPORT_CONFLICT: WIN32_ERROR = WIN32_ERROR(816u32);
pub const ERROR_CERTIFICATE_VALIDATION_PREFERENCE_CONFLICT: WIN32_ERROR = WIN32_ERROR(817u32);
pub const ERROR_FT_READ_FROM_COPY_FAILURE: WIN32_ERROR = WIN32_ERROR(818u32);
pub const ERROR_SECTION_DIRECT_MAP_ONLY: WIN32_ERROR = WIN32_ERROR(819u32);
pub const ERROR_EA_ACCESS_DENIED: WIN32_ERROR = WIN32_ERROR(994u32);
pub const ERROR_OPERATION_ABORTED: WIN32_ERROR = WIN32_ERROR(995u32);
pub const ERROR_IO_INCOMPLETE: WIN32_ERROR = WIN32_ERROR(996u32);
pub const ERROR_IO_PENDING: WIN32_ERROR = WIN32_ERROR(997u32);
pub const ERROR_NOACCESS: WIN32_ERROR = WIN32_ERROR(998u32);
pub const ERROR_SWAPERROR: WIN32_ERROR = WIN32_ERROR(999u32);
pub const ERROR_STACK_OVERFLOW: WIN32_ERROR = WIN32_ERROR(1001u32);
pub const ERROR_INVALID_MESSAGE: WIN32_ERROR = WIN32_ERROR(1002u32);
pub const ERROR_CAN_NOT_COMPLETE: WIN32_ERROR = WIN32_ERROR(1003u32);
pub const ERROR_INVALID_FLAGS: WIN32_ERROR = WIN32_ERROR(1004u32);
pub const ERROR_UNRECOGNIZED_VOLUME: WIN32_ERROR = WIN32_ERROR(1005u32);
pub const ERROR_FILE_INVALID: WIN32_ERROR = WIN32_ERROR(1006u32);
pub const ERROR_FULLSCREEN_MODE: WIN32_ERROR = WIN32_ERROR(1007u32);
pub const ERROR_NO_TOKEN: WIN32_ERROR = WIN32_ERROR(1008u32);
pub const ERROR_BADDB: WIN32_ERROR = WIN32_ERROR(1009u32);
pub const ERROR_BADKEY: WIN32_ERROR = WIN32_ERROR(1010u32);
pub const ERROR_CANTOPEN: WIN32_ERROR = WIN32_ERROR(1011u32);
pub const ERROR_CANTREAD: WIN32_ERROR = WIN32_ERROR(1012u32);
pub const ERROR_CANTWRITE: WIN32_ERROR = WIN32_ERROR(1013u32);
pub const ERROR_REGISTRY_RECOVERED: WIN32_ERROR = WIN32_ERROR(1014u32);
pub const ERROR_REGISTRY_CORRUPT: WIN32_ERROR = WIN32_ERROR(1015u32);
pub const ERROR_REGISTRY_IO_FAILED: WIN32_ERROR = WIN32_ERROR(1016u32);
pub const ERROR_NOT_REGISTRY_FILE: WIN32_ERROR = WIN32_ERROR(1017u32);
pub const ERROR_KEY_DELETED: WIN32_ERROR = WIN32_ERROR(1018u32);
pub const ERROR_NO_LOG_SPACE: WIN32_ERROR = WIN32_ERROR(1019u32);
pub const ERROR_KEY_HAS_CHILDREN: WIN32_ERROR = WIN32_ERROR(1020u32);
pub const ERROR_CHILD_MUST_BE_VOLATILE: WIN32_ERROR = WIN32_ERROR(1021u32);
pub const ERROR_NOTIFY_ENUM_DIR: WIN32_ERROR = WIN32_ERROR(1022u32);
pub const ERROR_DEPENDENT_SERVICES_RUNNING: WIN32_ERROR = WIN32_ERROR(1051u32);
pub const ERROR_INVALID_SERVICE_CONTROL: WIN32_ERROR = WIN32_ERROR(1052u32);
pub const ERROR_SERVICE_REQUEST_TIMEOUT: WIN32_ERROR = WIN32_ERROR(1053u32);
pub const ERROR_SERVICE_NO_THREAD: WIN32_ERROR = WIN32_ERROR(1054u32);
pub const ERROR_SERVICE_DATABASE_LOCKED: WIN32_ERROR = WIN32_ERROR(1055u32);
pub const ERROR_SERVICE_ALREADY_RUNNING: WIN32_ERROR = WIN32_ERROR(1056u32);
pub const ERROR_INVALID_SERVICE_ACCOUNT: WIN32_ERROR = WIN32_ERROR(1057u32);
pub const ERROR_SERVICE_DISABLED: WIN32_ERROR = WIN32_ERROR(1058u32);
pub const ERROR_CIRCULAR_DEPENDENCY: WIN32_ERROR = WIN32_ERROR(1059u32);
pub const ERROR_SERVICE_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(1060u32);
pub const ERROR_SERVICE_CANNOT_ACCEPT_CTRL: WIN32_ERROR = WIN32_ERROR(1061u32);
pub const ERROR_SERVICE_NOT_ACTIVE: WIN32_ERROR = WIN32_ERROR(1062u32);
pub const ERROR_FAILED_SERVICE_CONTROLLER_CONNECT: WIN32_ERROR = WIN32_ERROR(1063u32);
pub const ERROR_EXCEPTION_IN_SERVICE: WIN32_ERROR = WIN32_ERROR(1064u32);
pub const ERROR_DATABASE_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(1065u32);
pub const ERROR_SERVICE_SPECIFIC_ERROR: WIN32_ERROR = WIN32_ERROR(1066u32);
pub const ERROR_PROCESS_ABORTED: WIN32_ERROR = WIN32_ERROR(1067u32);
pub const ERROR_SERVICE_DEPENDENCY_FAIL: WIN32_ERROR = WIN32_ERROR(1068u32);
pub const ERROR_SERVICE_LOGON_FAILED: WIN32_ERROR = WIN32_ERROR(1069u32);
pub const ERROR_SERVICE_START_HANG: WIN32_ERROR = WIN32_ERROR(1070u32);
pub const ERROR_INVALID_SERVICE_LOCK: WIN32_ERROR = WIN32_ERROR(1071u32);
pub const ERROR_SERVICE_MARKED_FOR_DELETE: WIN32_ERROR = WIN32_ERROR(1072u32);
pub const ERROR_SERVICE_EXISTS: WIN32_ERROR = WIN32_ERROR(1073u32);
pub const ERROR_ALREADY_RUNNING_LKG: WIN32_ERROR = WIN32_ERROR(1074u32);
pub const ERROR_SERVICE_DEPENDENCY_DELETED: WIN32_ERROR = WIN32_ERROR(1075u32);
pub const ERROR_BOOT_ALREADY_ACCEPTED: WIN32_ERROR = WIN32_ERROR(1076u32);
pub const ERROR_SERVICE_NEVER_STARTED: WIN32_ERROR = WIN32_ERROR(1077u32);
pub const ERROR_DUPLICATE_SERVICE_NAME: WIN32_ERROR = WIN32_ERROR(1078u32);
pub const ERROR_DIFFERENT_SERVICE_ACCOUNT: WIN32_ERROR = WIN32_ERROR(1079u32);
pub const ERROR_CANNOT_DETECT_DRIVER_FAILURE: WIN32_ERROR = WIN32_ERROR(1080u32);
pub const ERROR_CANNOT_DETECT_PROCESS_ABORT: WIN32_ERROR = WIN32_ERROR(1081u32);
pub const ERROR_NO_RECOVERY_PROGRAM: WIN32_ERROR = WIN32_ERROR(1082u32);
pub const ERROR_SERVICE_NOT_IN_EXE: WIN32_ERROR = WIN32_ERROR(1083u32);
pub const ERROR_NOT_SAFEBOOT_SERVICE: WIN32_ERROR = WIN32_ERROR(1084u32);
pub const ERROR_END_OF_MEDIA: WIN32_ERROR = WIN32_ERROR(1100u32);
pub const ERROR_FILEMARK_DETECTED: WIN32_ERROR = WIN32_ERROR(1101u32);
pub const ERROR_BEGINNING_OF_MEDIA: WIN32_ERROR = WIN32_ERROR(1102u32);
pub const ERROR_SETMARK_DETECTED: WIN32_ERROR = WIN32_ERROR(1103u32);
pub const ERROR_NO_DATA_DETECTED: WIN32_ERROR = WIN32_ERROR(1104u32);
pub const ERROR_PARTITION_FAILURE: WIN32_ERROR = WIN32_ERROR(1105u32);
pub const ERROR_INVALID_BLOCK_LENGTH: WIN32_ERROR = WIN32_ERROR(1106u32);
pub const ERROR_DEVICE_NOT_PARTITIONED: WIN32_ERROR = WIN32_ERROR(1107u32);
pub const ERROR_UNABLE_TO_LOCK_MEDIA: WIN32_ERROR = WIN32_ERROR(1108u32);
pub const ERROR_UNABLE_TO_UNLOAD_MEDIA: WIN32_ERROR = WIN32_ERROR(1109u32);
pub const ERROR_MEDIA_CHANGED: WIN32_ERROR = WIN32_ERROR(1110u32);
pub const ERROR_BUS_RESET: WIN32_ERROR = WIN32_ERROR(1111u32);
pub const ERROR_NO_MEDIA_IN_DRIVE: WIN32_ERROR = WIN32_ERROR(1112u32);
pub const ERROR_NO_UNICODE_TRANSLATION: WIN32_ERROR = WIN32_ERROR(1113u32);
pub const ERROR_DLL_INIT_FAILED: WIN32_ERROR = WIN32_ERROR(1114u32);
pub const ERROR_SHUTDOWN_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(1115u32);
pub const ERROR_NO_SHUTDOWN_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(1116u32);
pub const ERROR_IO_DEVICE: WIN32_ERROR = WIN32_ERROR(1117u32);
pub const ERROR_SERIAL_NO_DEVICE: WIN32_ERROR = WIN32_ERROR(1118u32);
pub const ERROR_IRQ_BUSY: WIN32_ERROR = WIN32_ERROR(1119u32);
pub const ERROR_MORE_WRITES: WIN32_ERROR = WIN32_ERROR(1120u32);
pub const ERROR_COUNTER_TIMEOUT: WIN32_ERROR = WIN32_ERROR(1121u32);
pub const ERROR_FLOPPY_ID_MARK_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1122u32);
pub const ERROR_FLOPPY_WRONG_CYLINDER: WIN32_ERROR = WIN32_ERROR(1123u32);
pub const ERROR_FLOPPY_UNKNOWN_ERROR: WIN32_ERROR = WIN32_ERROR(1124u32);
pub const ERROR_FLOPPY_BAD_REGISTERS: WIN32_ERROR = WIN32_ERROR(1125u32);
pub const ERROR_DISK_RECALIBRATE_FAILED: WIN32_ERROR = WIN32_ERROR(1126u32);
pub const ERROR_DISK_OPERATION_FAILED: WIN32_ERROR = WIN32_ERROR(1127u32);
pub const ERROR_DISK_RESET_FAILED: WIN32_ERROR = WIN32_ERROR(1128u32);
pub const ERROR_EOM_OVERFLOW: WIN32_ERROR = WIN32_ERROR(1129u32);
pub const ERROR_NOT_ENOUGH_SERVER_MEMORY: WIN32_ERROR = WIN32_ERROR(1130u32);
pub const ERROR_POSSIBLE_DEADLOCK: WIN32_ERROR = WIN32_ERROR(1131u32);
pub const ERROR_MAPPED_ALIGNMENT: WIN32_ERROR = WIN32_ERROR(1132u32);
pub const ERROR_SET_POWER_STATE_VETOED: WIN32_ERROR = WIN32_ERROR(1140u32);
pub const ERROR_SET_POWER_STATE_FAILED: WIN32_ERROR = WIN32_ERROR(1141u32);
pub const ERROR_TOO_MANY_LINKS: WIN32_ERROR = WIN32_ERROR(1142u32);
pub const ERROR_OLD_WIN_VERSION: WIN32_ERROR = WIN32_ERROR(1150u32);
pub const ERROR_APP_WRONG_OS: WIN32_ERROR = WIN32_ERROR(1151u32);
pub const ERROR_SINGLE_INSTANCE_APP: WIN32_ERROR = WIN32_ERROR(1152u32);
pub const ERROR_RMODE_APP: WIN32_ERROR = WIN32_ERROR(1153u32);
pub const ERROR_INVALID_DLL: WIN32_ERROR = WIN32_ERROR(1154u32);
pub const ERROR_NO_ASSOCIATION: WIN32_ERROR = WIN32_ERROR(1155u32);
pub const ERROR_DDE_FAIL: WIN32_ERROR = WIN32_ERROR(1156u32);
pub const ERROR_DLL_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1157u32);
pub const ERROR_NO_MORE_USER_HANDLES: WIN32_ERROR = WIN32_ERROR(1158u32);
pub const ERROR_MESSAGE_SYNC_ONLY: WIN32_ERROR = WIN32_ERROR(1159u32);
pub const ERROR_SOURCE_ELEMENT_EMPTY: WIN32_ERROR = WIN32_ERROR(1160u32);
pub const ERROR_DESTINATION_ELEMENT_FULL: WIN32_ERROR = WIN32_ERROR(1161u32);
pub const ERROR_ILLEGAL_ELEMENT_ADDRESS: WIN32_ERROR = WIN32_ERROR(1162u32);
pub const ERROR_MAGAZINE_NOT_PRESENT: WIN32_ERROR = WIN32_ERROR(1163u32);
pub const ERROR_DEVICE_REINITIALIZATION_NEEDED: WIN32_ERROR = WIN32_ERROR(1164u32);
pub const ERROR_DEVICE_REQUIRES_CLEANING: WIN32_ERROR = WIN32_ERROR(1165u32);
pub const ERROR_DEVICE_DOOR_OPEN: WIN32_ERROR = WIN32_ERROR(1166u32);
pub const ERROR_DEVICE_NOT_CONNECTED: WIN32_ERROR = WIN32_ERROR(1167u32);
pub const ERROR_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1168u32);
pub const ERROR_NO_MATCH: WIN32_ERROR = WIN32_ERROR(1169u32);
pub const ERROR_SET_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1170u32);
pub const ERROR_POINT_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1171u32);
pub const ERROR_NO_TRACKING_SERVICE: WIN32_ERROR = WIN32_ERROR(1172u32);
pub const ERROR_NO_VOLUME_ID: WIN32_ERROR = WIN32_ERROR(1173u32);
pub const ERROR_UNABLE_TO_REMOVE_REPLACED: WIN32_ERROR = WIN32_ERROR(1175u32);
pub const ERROR_UNABLE_TO_MOVE_REPLACEMENT: WIN32_ERROR = WIN32_ERROR(1176u32);
pub const ERROR_UNABLE_TO_MOVE_REPLACEMENT_2: WIN32_ERROR = WIN32_ERROR(1177u32);
pub const ERROR_JOURNAL_DELETE_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(1178u32);
pub const ERROR_JOURNAL_NOT_ACTIVE: WIN32_ERROR = WIN32_ERROR(1179u32);
pub const ERROR_POTENTIAL_FILE_FOUND: WIN32_ERROR = WIN32_ERROR(1180u32);
pub const ERROR_JOURNAL_ENTRY_DELETED: WIN32_ERROR = WIN32_ERROR(1181u32);
pub const ERROR_PARTITION_TERMINATING: WIN32_ERROR = WIN32_ERROR(1184u32);
pub const ERROR_SHUTDOWN_IS_SCHEDULED: WIN32_ERROR = WIN32_ERROR(1190u32);
pub const ERROR_SHUTDOWN_USERS_LOGGED_ON: WIN32_ERROR = WIN32_ERROR(1191u32);
pub const ERROR_SHUTDOWN_DISKS_NOT_IN_MAINTENANCE_MODE: WIN32_ERROR = WIN32_ERROR(1192u32);
pub const ERROR_BAD_DEVICE: WIN32_ERROR = WIN32_ERROR(1200u32);
pub const ERROR_CONNECTION_UNAVAIL: WIN32_ERROR = WIN32_ERROR(1201u32);
pub const ERROR_DEVICE_ALREADY_REMEMBERED: WIN32_ERROR = WIN32_ERROR(1202u32);
pub const ERROR_NO_NET_OR_BAD_PATH: WIN32_ERROR = WIN32_ERROR(1203u32);
pub const ERROR_BAD_PROVIDER: WIN32_ERROR = WIN32_ERROR(1204u32);
pub const ERROR_CANNOT_OPEN_PROFILE: WIN32_ERROR = WIN32_ERROR(1205u32);
pub const ERROR_BAD_PROFILE: WIN32_ERROR = WIN32_ERROR(1206u32);
pub const ERROR_NOT_CONTAINER: WIN32_ERROR = WIN32_ERROR(1207u32);
pub const ERROR_EXTENDED_ERROR: WIN32_ERROR = WIN32_ERROR(1208u32);
pub const ERROR_INVALID_GROUPNAME: WIN32_ERROR = WIN32_ERROR(1209u32);
pub const ERROR_INVALID_COMPUTERNAME: WIN32_ERROR = WIN32_ERROR(1210u32);
pub const ERROR_INVALID_EVENTNAME: WIN32_ERROR = WIN32_ERROR(1211u32);
pub const ERROR_INVALID_DOMAINNAME: WIN32_ERROR = WIN32_ERROR(1212u32);
pub const ERROR_INVALID_SERVICENAME: WIN32_ERROR = WIN32_ERROR(1213u32);
pub const ERROR_INVALID_NETNAME: WIN32_ERROR = WIN32_ERROR(1214u32);
pub const ERROR_INVALID_SHARENAME: WIN32_ERROR = WIN32_ERROR(1215u32);
pub const ERROR_INVALID_PASSWORDNAME: WIN32_ERROR = WIN32_ERROR(1216u32);
pub const ERROR_INVALID_MESSAGENAME: WIN32_ERROR = WIN32_ERROR(1217u32);
pub const ERROR_INVALID_MESSAGEDEST: WIN32_ERROR = WIN32_ERROR(1218u32);
pub const ERROR_SESSION_CREDENTIAL_CONFLICT: WIN32_ERROR = WIN32_ERROR(1219u32);
pub const ERROR_REMOTE_SESSION_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(1220u32);
pub const ERROR_DUP_DOMAINNAME: WIN32_ERROR = WIN32_ERROR(1221u32);
pub const ERROR_NO_NETWORK: WIN32_ERROR = WIN32_ERROR(1222u32);
pub const ERROR_CANCELLED: WIN32_ERROR = WIN32_ERROR(1223u32);
pub const ERROR_USER_MAPPED_FILE: WIN32_ERROR = WIN32_ERROR(1224u32);
pub const ERROR_CONNECTION_REFUSED: WIN32_ERROR = WIN32_ERROR(1225u32);
pub const ERROR_GRACEFUL_DISCONNECT: WIN32_ERROR = WIN32_ERROR(1226u32);
pub const ERROR_ADDRESS_ALREADY_ASSOCIATED: WIN32_ERROR = WIN32_ERROR(1227u32);
pub const ERROR_ADDRESS_NOT_ASSOCIATED: WIN32_ERROR = WIN32_ERROR(1228u32);
pub const ERROR_CONNECTION_INVALID: WIN32_ERROR = WIN32_ERROR(1229u32);
pub const ERROR_CONNECTION_ACTIVE: WIN32_ERROR = WIN32_ERROR(1230u32);
pub const ERROR_NETWORK_UNREACHABLE: WIN32_ERROR = WIN32_ERROR(1231u32);
pub const ERROR_HOST_UNREACHABLE: WIN32_ERROR = WIN32_ERROR(1232u32);
pub const ERROR_PROTOCOL_UNREACHABLE: WIN32_ERROR = WIN32_ERROR(1233u32);
pub const ERROR_PORT_UNREACHABLE: WIN32_ERROR = WIN32_ERROR(1234u32);
pub const ERROR_REQUEST_ABORTED: WIN32_ERROR = WIN32_ERROR(1235u32);
pub const ERROR_CONNECTION_ABORTED: WIN32_ERROR = WIN32_ERROR(1236u32);
pub const ERROR_RETRY: WIN32_ERROR = WIN32_ERROR(1237u32);
pub const ERROR_CONNECTION_COUNT_LIMIT: WIN32_ERROR = WIN32_ERROR(1238u32);
pub const ERROR_LOGIN_TIME_RESTRICTION: WIN32_ERROR = WIN32_ERROR(1239u32);
pub const ERROR_LOGIN_WKSTA_RESTRICTION: WIN32_ERROR = WIN32_ERROR(1240u32);
pub const ERROR_INCORRECT_ADDRESS: WIN32_ERROR = WIN32_ERROR(1241u32);
pub const ERROR_ALREADY_REGISTERED: WIN32_ERROR = WIN32_ERROR(1242u32);
pub const ERROR_SERVICE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1243u32);
pub const ERROR_NOT_AUTHENTICATED: WIN32_ERROR = WIN32_ERROR(1244u32);
pub const ERROR_NOT_LOGGED_ON: WIN32_ERROR = WIN32_ERROR(1245u32);
pub const ERROR_CONTINUE: WIN32_ERROR = WIN32_ERROR(1246u32);
pub const ERROR_ALREADY_INITIALIZED: WIN32_ERROR = WIN32_ERROR(1247u32);
pub const ERROR_NO_MORE_DEVICES: WIN32_ERROR = WIN32_ERROR(1248u32);
pub const ERROR_NO_SUCH_SITE: WIN32_ERROR = WIN32_ERROR(1249u32);
pub const ERROR_DOMAIN_CONTROLLER_EXISTS: WIN32_ERROR = WIN32_ERROR(1250u32);
pub const ERROR_ONLY_IF_CONNECTED: WIN32_ERROR = WIN32_ERROR(1251u32);
pub const ERROR_OVERRIDE_NOCHANGES: WIN32_ERROR = WIN32_ERROR(1252u32);
pub const ERROR_BAD_USER_PROFILE: WIN32_ERROR = WIN32_ERROR(1253u32);
pub const ERROR_NOT_SUPPORTED_ON_SBS: WIN32_ERROR = WIN32_ERROR(1254u32);
pub const ERROR_SERVER_SHUTDOWN_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(1255u32);
pub const ERROR_HOST_DOWN: WIN32_ERROR = WIN32_ERROR(1256u32);
pub const ERROR_NON_ACCOUNT_SID: WIN32_ERROR = WIN32_ERROR(1257u32);
pub const ERROR_NON_DOMAIN_SID: WIN32_ERROR = WIN32_ERROR(1258u32);
pub const ERROR_APPHELP_BLOCK: WIN32_ERROR = WIN32_ERROR(1259u32);
pub const ERROR_ACCESS_DISABLED_BY_POLICY: WIN32_ERROR = WIN32_ERROR(1260u32);
pub const ERROR_REG_NAT_CONSUMPTION: WIN32_ERROR = WIN32_ERROR(1261u32);
pub const ERROR_CSCSHARE_OFFLINE: WIN32_ERROR = WIN32_ERROR(1262u32);
pub const ERROR_PKINIT_FAILURE: WIN32_ERROR = WIN32_ERROR(1263u32);
pub const ERROR_SMARTCARD_SUBSYSTEM_FAILURE: WIN32_ERROR = WIN32_ERROR(1264u32);
pub const ERROR_DOWNGRADE_DETECTED: WIN32_ERROR = WIN32_ERROR(1265u32);
pub const ERROR_MACHINE_LOCKED: WIN32_ERROR = WIN32_ERROR(1271u32);
pub const ERROR_SMB_GUEST_LOGON_BLOCKED: WIN32_ERROR = WIN32_ERROR(1272u32);
pub const ERROR_CALLBACK_SUPPLIED_INVALID_DATA: WIN32_ERROR = WIN32_ERROR(1273u32);
pub const ERROR_SYNC_FOREGROUND_REFRESH_REQUIRED: WIN32_ERROR = WIN32_ERROR(1274u32);
pub const ERROR_DRIVER_BLOCKED: WIN32_ERROR = WIN32_ERROR(1275u32);
pub const ERROR_INVALID_IMPORT_OF_NON_DLL: WIN32_ERROR = WIN32_ERROR(1276u32);
pub const ERROR_ACCESS_DISABLED_WEBBLADE: WIN32_ERROR = WIN32_ERROR(1277u32);
pub const ERROR_ACCESS_DISABLED_WEBBLADE_TAMPER: WIN32_ERROR = WIN32_ERROR(1278u32);
pub const ERROR_RECOVERY_FAILURE: WIN32_ERROR = WIN32_ERROR(1279u32);
pub const ERROR_ALREADY_FIBER: WIN32_ERROR = WIN32_ERROR(1280u32);
pub const ERROR_ALREADY_THREAD: WIN32_ERROR = WIN32_ERROR(1281u32);
pub const ERROR_STACK_BUFFER_OVERRUN: WIN32_ERROR = WIN32_ERROR(1282u32);
pub const ERROR_PARAMETER_QUOTA_EXCEEDED: WIN32_ERROR = WIN32_ERROR(1283u32);
pub const ERROR_DEBUGGER_INACTIVE: WIN32_ERROR = WIN32_ERROR(1284u32);
pub const ERROR_DELAY_LOAD_FAILED: WIN32_ERROR = WIN32_ERROR(1285u32);
pub const ERROR_VDM_DISALLOWED: WIN32_ERROR = WIN32_ERROR(1286u32);
pub const ERROR_UNIDENTIFIED_ERROR: WIN32_ERROR = WIN32_ERROR(1287u32);
pub const ERROR_INVALID_CRUNTIME_PARAMETER: WIN32_ERROR = WIN32_ERROR(1288u32);
pub const ERROR_BEYOND_VDL: WIN32_ERROR = WIN32_ERROR(1289u32);
pub const ERROR_INCOMPATIBLE_SERVICE_SID_TYPE: WIN32_ERROR = WIN32_ERROR(1290u32);
pub const ERROR_DRIVER_PROCESS_TERMINATED: WIN32_ERROR = WIN32_ERROR(1291u32);
pub const ERROR_IMPLEMENTATION_LIMIT: WIN32_ERROR = WIN32_ERROR(1292u32);
pub const ERROR_PROCESS_IS_PROTECTED: WIN32_ERROR = WIN32_ERROR(1293u32);
pub const ERROR_SERVICE_NOTIFY_CLIENT_LAGGING: WIN32_ERROR = WIN32_ERROR(1294u32);
pub const ERROR_DISK_QUOTA_EXCEEDED: WIN32_ERROR = WIN32_ERROR(1295u32);
pub const ERROR_CONTENT_BLOCKED: WIN32_ERROR = WIN32_ERROR(1296u32);
pub const ERROR_INCOMPATIBLE_SERVICE_PRIVILEGE: WIN32_ERROR = WIN32_ERROR(1297u32);
pub const ERROR_APP_HANG: WIN32_ERROR = WIN32_ERROR(1298u32);
pub const ERROR_INVALID_LABEL: WIN32_ERROR = WIN32_ERROR(1299u32);
pub const ERROR_NOT_ALL_ASSIGNED: WIN32_ERROR = WIN32_ERROR(1300u32);
pub const ERROR_SOME_NOT_MAPPED: WIN32_ERROR = WIN32_ERROR(1301u32);
pub const ERROR_NO_QUOTAS_FOR_ACCOUNT: WIN32_ERROR = WIN32_ERROR(1302u32);
pub const ERROR_LOCAL_USER_SESSION_KEY: WIN32_ERROR = WIN32_ERROR(1303u32);
pub const ERROR_NULL_LM_PASSWORD: WIN32_ERROR = WIN32_ERROR(1304u32);
pub const ERROR_UNKNOWN_REVISION: WIN32_ERROR = WIN32_ERROR(1305u32);
pub const ERROR_REVISION_MISMATCH: WIN32_ERROR = WIN32_ERROR(1306u32);
pub const ERROR_INVALID_OWNER: WIN32_ERROR = WIN32_ERROR(1307u32);
pub const ERROR_INVALID_PRIMARY_GROUP: WIN32_ERROR = WIN32_ERROR(1308u32);
pub const ERROR_NO_IMPERSONATION_TOKEN: WIN32_ERROR = WIN32_ERROR(1309u32);
pub const ERROR_CANT_DISABLE_MANDATORY: WIN32_ERROR = WIN32_ERROR(1310u32);
pub const ERROR_NO_LOGON_SERVERS: WIN32_ERROR = WIN32_ERROR(1311u32);
pub const ERROR_NO_SUCH_LOGON_SESSION: WIN32_ERROR = WIN32_ERROR(1312u32);
pub const ERROR_NO_SUCH_PRIVILEGE: WIN32_ERROR = WIN32_ERROR(1313u32);
pub const ERROR_PRIVILEGE_NOT_HELD: WIN32_ERROR = WIN32_ERROR(1314u32);
pub const ERROR_INVALID_ACCOUNT_NAME: WIN32_ERROR = WIN32_ERROR(1315u32);
pub const ERROR_USER_EXISTS: WIN32_ERROR = WIN32_ERROR(1316u32);
pub const ERROR_NO_SUCH_USER: WIN32_ERROR = WIN32_ERROR(1317u32);
pub const ERROR_GROUP_EXISTS: WIN32_ERROR = WIN32_ERROR(1318u32);
pub const ERROR_NO_SUCH_GROUP: WIN32_ERROR = WIN32_ERROR(1319u32);
pub const ERROR_MEMBER_IN_GROUP: WIN32_ERROR = WIN32_ERROR(1320u32);
pub const ERROR_MEMBER_NOT_IN_GROUP: WIN32_ERROR = WIN32_ERROR(1321u32);
pub const ERROR_LAST_ADMIN: WIN32_ERROR = WIN32_ERROR(1322u32);
pub const ERROR_WRONG_PASSWORD: WIN32_ERROR = WIN32_ERROR(1323u32);
pub const ERROR_ILL_FORMED_PASSWORD: WIN32_ERROR = WIN32_ERROR(1324u32);
pub const ERROR_PASSWORD_RESTRICTION: WIN32_ERROR = WIN32_ERROR(1325u32);
pub const ERROR_LOGON_FAILURE: WIN32_ERROR = WIN32_ERROR(1326u32);
pub const ERROR_ACCOUNT_RESTRICTION: WIN32_ERROR = WIN32_ERROR(1327u32);
pub const ERROR_INVALID_LOGON_HOURS: WIN32_ERROR = WIN32_ERROR(1328u32);
pub const ERROR_INVALID_WORKSTATION: WIN32_ERROR = WIN32_ERROR(1329u32);
pub const ERROR_PASSWORD_EXPIRED: WIN32_ERROR = WIN32_ERROR(1330u32);
pub const ERROR_ACCOUNT_DISABLED: WIN32_ERROR = WIN32_ERROR(1331u32);
pub const ERROR_NONE_MAPPED: WIN32_ERROR = WIN32_ERROR(1332u32);
pub const ERROR_TOO_MANY_LUIDS_REQUESTED: WIN32_ERROR = WIN32_ERROR(1333u32);
pub const ERROR_LUIDS_EXHAUSTED: WIN32_ERROR = WIN32_ERROR(1334u32);
pub const ERROR_INVALID_SUB_AUTHORITY: WIN32_ERROR = WIN32_ERROR(1335u32);
pub const ERROR_INVALID_ACL: WIN32_ERROR = WIN32_ERROR(1336u32);
pub const ERROR_INVALID_SID: WIN32_ERROR = WIN32_ERROR(1337u32);
pub const ERROR_INVALID_SECURITY_DESCR: WIN32_ERROR = WIN32_ERROR(1338u32);
pub const ERROR_BAD_INHERITANCE_ACL: WIN32_ERROR = WIN32_ERROR(1340u32);
pub const ERROR_SERVER_DISABLED: WIN32_ERROR = WIN32_ERROR(1341u32);
pub const ERROR_SERVER_NOT_DISABLED: WIN32_ERROR = WIN32_ERROR(1342u32);
pub const ERROR_INVALID_ID_AUTHORITY: WIN32_ERROR = WIN32_ERROR(1343u32);
pub const ERROR_ALLOTTED_SPACE_EXCEEDED: WIN32_ERROR = WIN32_ERROR(1344u32);
pub const ERROR_INVALID_GROUP_ATTRIBUTES: WIN32_ERROR = WIN32_ERROR(1345u32);
pub const ERROR_BAD_IMPERSONATION_LEVEL: WIN32_ERROR = WIN32_ERROR(1346u32);
pub const ERROR_CANT_OPEN_ANONYMOUS: WIN32_ERROR = WIN32_ERROR(1347u32);
pub const ERROR_BAD_VALIDATION_CLASS: WIN32_ERROR = WIN32_ERROR(1348u32);
pub const ERROR_BAD_TOKEN_TYPE: WIN32_ERROR = WIN32_ERROR(1349u32);
pub const ERROR_NO_SECURITY_ON_OBJECT: WIN32_ERROR = WIN32_ERROR(1350u32);
pub const ERROR_CANT_ACCESS_DOMAIN_INFO: WIN32_ERROR = WIN32_ERROR(1351u32);
pub const ERROR_INVALID_SERVER_STATE: WIN32_ERROR = WIN32_ERROR(1352u32);
pub const ERROR_INVALID_DOMAIN_STATE: WIN32_ERROR = WIN32_ERROR(1353u32);
pub const ERROR_INVALID_DOMAIN_ROLE: WIN32_ERROR = WIN32_ERROR(1354u32);
pub const ERROR_NO_SUCH_DOMAIN: WIN32_ERROR = WIN32_ERROR(1355u32);
pub const ERROR_DOMAIN_EXISTS: WIN32_ERROR = WIN32_ERROR(1356u32);
pub const ERROR_DOMAIN_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(1357u32);
pub const ERROR_INTERNAL_DB_CORRUPTION: WIN32_ERROR = WIN32_ERROR(1358u32);
pub const ERROR_INTERNAL_ERROR: WIN32_ERROR = WIN32_ERROR(1359u32);
pub const ERROR_GENERIC_NOT_MAPPED: WIN32_ERROR = WIN32_ERROR(1360u32);
pub const ERROR_BAD_DESCRIPTOR_FORMAT: WIN32_ERROR = WIN32_ERROR(1361u32);
pub const ERROR_NOT_LOGON_PROCESS: WIN32_ERROR = WIN32_ERROR(1362u32);
pub const ERROR_LOGON_SESSION_EXISTS: WIN32_ERROR = WIN32_ERROR(1363u32);
pub const ERROR_NO_SUCH_PACKAGE: WIN32_ERROR = WIN32_ERROR(1364u32);
pub const ERROR_BAD_LOGON_SESSION_STATE: WIN32_ERROR = WIN32_ERROR(1365u32);
pub const ERROR_LOGON_SESSION_COLLISION: WIN32_ERROR = WIN32_ERROR(1366u32);
pub const ERROR_INVALID_LOGON_TYPE: WIN32_ERROR = WIN32_ERROR(1367u32);
pub const ERROR_CANNOT_IMPERSONATE: WIN32_ERROR = WIN32_ERROR(1368u32);
pub const ERROR_RXACT_INVALID_STATE: WIN32_ERROR = WIN32_ERROR(1369u32);
pub const ERROR_RXACT_COMMIT_FAILURE: WIN32_ERROR = WIN32_ERROR(1370u32);
pub const ERROR_SPECIAL_ACCOUNT: WIN32_ERROR = WIN32_ERROR(1371u32);
pub const ERROR_SPECIAL_GROUP: WIN32_ERROR = WIN32_ERROR(1372u32);
pub const ERROR_SPECIAL_USER: WIN32_ERROR = WIN32_ERROR(1373u32);
pub const ERROR_MEMBERS_PRIMARY_GROUP: WIN32_ERROR = WIN32_ERROR(1374u32);
pub const ERROR_TOKEN_ALREADY_IN_USE: WIN32_ERROR = WIN32_ERROR(1375u32);
pub const ERROR_NO_SUCH_ALIAS: WIN32_ERROR = WIN32_ERROR(1376u32);
pub const ERROR_MEMBER_NOT_IN_ALIAS: WIN32_ERROR = WIN32_ERROR(1377u32);
pub const ERROR_MEMBER_IN_ALIAS: WIN32_ERROR = WIN32_ERROR(1378u32);
pub const ERROR_ALIAS_EXISTS: WIN32_ERROR = WIN32_ERROR(1379u32);
pub const ERROR_LOGON_NOT_GRANTED: WIN32_ERROR = WIN32_ERROR(1380u32);
pub const ERROR_TOO_MANY_SECRETS: WIN32_ERROR = WIN32_ERROR(1381u32);
pub const ERROR_SECRET_TOO_LONG: WIN32_ERROR = WIN32_ERROR(1382u32);
pub const ERROR_INTERNAL_DB_ERROR: WIN32_ERROR = WIN32_ERROR(1383u32);
pub const ERROR_TOO_MANY_CONTEXT_IDS: WIN32_ERROR = WIN32_ERROR(1384u32);
pub const ERROR_LOGON_TYPE_NOT_GRANTED: WIN32_ERROR = WIN32_ERROR(1385u32);
pub const ERROR_NT_CROSS_ENCRYPTION_REQUIRED: WIN32_ERROR = WIN32_ERROR(1386u32);
pub const ERROR_NO_SUCH_MEMBER: WIN32_ERROR = WIN32_ERROR(1387u32);
pub const ERROR_INVALID_MEMBER: WIN32_ERROR = WIN32_ERROR(1388u32);
pub const ERROR_TOO_MANY_SIDS: WIN32_ERROR = WIN32_ERROR(1389u32);
pub const ERROR_LM_CROSS_ENCRYPTION_REQUIRED: WIN32_ERROR = WIN32_ERROR(1390u32);
pub const ERROR_NO_INHERITANCE: WIN32_ERROR = WIN32_ERROR(1391u32);
pub const ERROR_FILE_CORRUPT: WIN32_ERROR = WIN32_ERROR(1392u32);
pub const ERROR_DISK_CORRUPT: WIN32_ERROR = WIN32_ERROR(1393u32);
pub const ERROR_NO_USER_SESSION_KEY: WIN32_ERROR = WIN32_ERROR(1394u32);
pub const ERROR_LICENSE_QUOTA_EXCEEDED: WIN32_ERROR = WIN32_ERROR(1395u32);
pub const ERROR_WRONG_TARGET_NAME: WIN32_ERROR = WIN32_ERROR(1396u32);
pub const ERROR_MUTUAL_AUTH_FAILED: WIN32_ERROR = WIN32_ERROR(1397u32);
pub const ERROR_TIME_SKEW: WIN32_ERROR = WIN32_ERROR(1398u32);
pub const ERROR_CURRENT_DOMAIN_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(1399u32);
pub const ERROR_INVALID_WINDOW_HANDLE: WIN32_ERROR = WIN32_ERROR(1400u32);
pub const ERROR_INVALID_MENU_HANDLE: WIN32_ERROR = WIN32_ERROR(1401u32);
pub const ERROR_INVALID_CURSOR_HANDLE: WIN32_ERROR = WIN32_ERROR(1402u32);
pub const ERROR_INVALID_ACCEL_HANDLE: WIN32_ERROR = WIN32_ERROR(1403u32);
pub const ERROR_INVALID_HOOK_HANDLE: WIN32_ERROR = WIN32_ERROR(1404u32);
pub const ERROR_INVALID_DWP_HANDLE: WIN32_ERROR = WIN32_ERROR(1405u32);
pub const ERROR_TLW_WITH_WSCHILD: WIN32_ERROR = WIN32_ERROR(1406u32);
pub const ERROR_CANNOT_FIND_WND_CLASS: WIN32_ERROR = WIN32_ERROR(1407u32);
pub const ERROR_WINDOW_OF_OTHER_THREAD: WIN32_ERROR = WIN32_ERROR(1408u32);
pub const ERROR_HOTKEY_ALREADY_REGISTERED: WIN32_ERROR = WIN32_ERROR(1409u32);
pub const ERROR_CLASS_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(1410u32);
pub const ERROR_CLASS_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(1411u32);
pub const ERROR_CLASS_HAS_WINDOWS: WIN32_ERROR = WIN32_ERROR(1412u32);
pub const ERROR_INVALID_INDEX: WIN32_ERROR = WIN32_ERROR(1413u32);
pub const ERROR_INVALID_ICON_HANDLE: WIN32_ERROR = WIN32_ERROR(1414u32);
pub const ERROR_PRIVATE_DIALOG_INDEX: WIN32_ERROR = WIN32_ERROR(1415u32);
pub const ERROR_LISTBOX_ID_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1416u32);
pub const ERROR_NO_WILDCARD_CHARACTERS: WIN32_ERROR = WIN32_ERROR(1417u32);
pub const ERROR_CLIPBOARD_NOT_OPEN: WIN32_ERROR = WIN32_ERROR(1418u32);
pub const ERROR_HOTKEY_NOT_REGISTERED: WIN32_ERROR = WIN32_ERROR(1419u32);
pub const ERROR_WINDOW_NOT_DIALOG: WIN32_ERROR = WIN32_ERROR(1420u32);
pub const ERROR_CONTROL_ID_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1421u32);
pub const ERROR_INVALID_COMBOBOX_MESSAGE: WIN32_ERROR = WIN32_ERROR(1422u32);
pub const ERROR_WINDOW_NOT_COMBOBOX: WIN32_ERROR = WIN32_ERROR(1423u32);
pub const ERROR_INVALID_EDIT_HEIGHT: WIN32_ERROR = WIN32_ERROR(1424u32);
pub const ERROR_DC_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1425u32);
pub const ERROR_INVALID_HOOK_FILTER: WIN32_ERROR = WIN32_ERROR(1426u32);
pub const ERROR_INVALID_FILTER_PROC: WIN32_ERROR = WIN32_ERROR(1427u32);
pub const ERROR_HOOK_NEEDS_HMOD: WIN32_ERROR = WIN32_ERROR(1428u32);
pub const ERROR_GLOBAL_ONLY_HOOK: WIN32_ERROR = WIN32_ERROR(1429u32);
pub const ERROR_JOURNAL_HOOK_SET: WIN32_ERROR = WIN32_ERROR(1430u32);
pub const ERROR_HOOK_NOT_INSTALLED: WIN32_ERROR = WIN32_ERROR(1431u32);
pub const ERROR_INVALID_LB_MESSAGE: WIN32_ERROR = WIN32_ERROR(1432u32);
pub const ERROR_SETCOUNT_ON_BAD_LB: WIN32_ERROR = WIN32_ERROR(1433u32);
pub const ERROR_LB_WITHOUT_TABSTOPS: WIN32_ERROR = WIN32_ERROR(1434u32);
pub const ERROR_DESTROY_OBJECT_OF_OTHER_THREAD: WIN32_ERROR = WIN32_ERROR(1435u32);
pub const ERROR_CHILD_WINDOW_MENU: WIN32_ERROR = WIN32_ERROR(1436u32);
pub const ERROR_NO_SYSTEM_MENU: WIN32_ERROR = WIN32_ERROR(1437u32);
pub const ERROR_INVALID_MSGBOX_STYLE: WIN32_ERROR = WIN32_ERROR(1438u32);
pub const ERROR_INVALID_SPI_VALUE: WIN32_ERROR = WIN32_ERROR(1439u32);
pub const ERROR_SCREEN_ALREADY_LOCKED: WIN32_ERROR = WIN32_ERROR(1440u32);
pub const ERROR_HWNDS_HAVE_DIFF_PARENT: WIN32_ERROR = WIN32_ERROR(1441u32);
pub const ERROR_NOT_CHILD_WINDOW: WIN32_ERROR = WIN32_ERROR(1442u32);
pub const ERROR_INVALID_GW_COMMAND: WIN32_ERROR = WIN32_ERROR(1443u32);
pub const ERROR_INVALID_THREAD_ID: WIN32_ERROR = WIN32_ERROR(1444u32);
pub const ERROR_NON_MDICHILD_WINDOW: WIN32_ERROR = WIN32_ERROR(1445u32);
pub const ERROR_POPUP_ALREADY_ACTIVE: WIN32_ERROR = WIN32_ERROR(1446u32);
pub const ERROR_NO_SCROLLBARS: WIN32_ERROR = WIN32_ERROR(1447u32);
pub const ERROR_INVALID_SCROLLBAR_RANGE: WIN32_ERROR = WIN32_ERROR(1448u32);
pub const ERROR_INVALID_SHOWWIN_COMMAND: WIN32_ERROR = WIN32_ERROR(1449u32);
pub const ERROR_NO_SYSTEM_RESOURCES: WIN32_ERROR = WIN32_ERROR(1450u32);
pub const ERROR_NONPAGED_SYSTEM_RESOURCES: WIN32_ERROR = WIN32_ERROR(1451u32);
pub const ERROR_PAGED_SYSTEM_RESOURCES: WIN32_ERROR = WIN32_ERROR(1452u32);
pub const ERROR_WORKING_SET_QUOTA: WIN32_ERROR = WIN32_ERROR(1453u32);
pub const ERROR_PAGEFILE_QUOTA: WIN32_ERROR = WIN32_ERROR(1454u32);
pub const ERROR_COMMITMENT_LIMIT: WIN32_ERROR = WIN32_ERROR(1455u32);
pub const ERROR_MENU_ITEM_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1456u32);
pub const ERROR_INVALID_KEYBOARD_HANDLE: WIN32_ERROR = WIN32_ERROR(1457u32);
pub const ERROR_HOOK_TYPE_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(1458u32);
pub const ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION: WIN32_ERROR = WIN32_ERROR(1459u32);
pub const ERROR_TIMEOUT: WIN32_ERROR = WIN32_ERROR(1460u32);
pub const ERROR_INVALID_MONITOR_HANDLE: WIN32_ERROR = WIN32_ERROR(1461u32);
pub const ERROR_INCORRECT_SIZE: WIN32_ERROR = WIN32_ERROR(1462u32);
pub const ERROR_SYMLINK_CLASS_DISABLED: WIN32_ERROR = WIN32_ERROR(1463u32);
pub const ERROR_SYMLINK_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(1464u32);
pub const ERROR_XML_PARSE_ERROR: WIN32_ERROR = WIN32_ERROR(1465u32);
pub const ERROR_XMLDSIG_ERROR: WIN32_ERROR = WIN32_ERROR(1466u32);
pub const ERROR_RESTART_APPLICATION: WIN32_ERROR = WIN32_ERROR(1467u32);
pub const ERROR_WRONG_COMPARTMENT: WIN32_ERROR = WIN32_ERROR(1468u32);
pub const ERROR_AUTHIP_FAILURE: WIN32_ERROR = WIN32_ERROR(1469u32);
pub const ERROR_NO_NVRAM_RESOURCES: WIN32_ERROR = WIN32_ERROR(1470u32);
pub const ERROR_NOT_GUI_PROCESS: WIN32_ERROR = WIN32_ERROR(1471u32);
pub const ERROR_EVENTLOG_FILE_CORRUPT: WIN32_ERROR = WIN32_ERROR(1500u32);
pub const ERROR_EVENTLOG_CANT_START: WIN32_ERROR = WIN32_ERROR(1501u32);
pub const ERROR_LOG_FILE_FULL: WIN32_ERROR = WIN32_ERROR(1502u32);
pub const ERROR_EVENTLOG_FILE_CHANGED: WIN32_ERROR = WIN32_ERROR(1503u32);
pub const ERROR_CONTAINER_ASSIGNED: WIN32_ERROR = WIN32_ERROR(1504u32);
pub const ERROR_JOB_NO_CONTAINER: WIN32_ERROR = WIN32_ERROR(1505u32);
pub const ERROR_INVALID_TASK_NAME: WIN32_ERROR = WIN32_ERROR(1550u32);
pub const ERROR_INVALID_TASK_INDEX: WIN32_ERROR = WIN32_ERROR(1551u32);
pub const ERROR_THREAD_ALREADY_IN_TASK: WIN32_ERROR = WIN32_ERROR(1552u32);
pub const ERROR_INSTALL_SERVICE_FAILURE: WIN32_ERROR = WIN32_ERROR(1601u32);
pub const ERROR_INSTALL_USEREXIT: WIN32_ERROR = WIN32_ERROR(1602u32);
pub const ERROR_INSTALL_FAILURE: WIN32_ERROR = WIN32_ERROR(1603u32);
pub const ERROR_INSTALL_SUSPEND: WIN32_ERROR = WIN32_ERROR(1604u32);
pub const ERROR_UNKNOWN_PRODUCT: WIN32_ERROR = WIN32_ERROR(1605u32);
pub const ERROR_UNKNOWN_FEATURE: WIN32_ERROR = WIN32_ERROR(1606u32);
pub const ERROR_UNKNOWN_COMPONENT: WIN32_ERROR = WIN32_ERROR(1607u32);
pub const ERROR_UNKNOWN_PROPERTY: WIN32_ERROR = WIN32_ERROR(1608u32);
pub const ERROR_INVALID_HANDLE_STATE: WIN32_ERROR = WIN32_ERROR(1609u32);
pub const ERROR_BAD_CONFIGURATION: WIN32_ERROR = WIN32_ERROR(1610u32);
pub const ERROR_INDEX_ABSENT: WIN32_ERROR = WIN32_ERROR(1611u32);
pub const ERROR_INSTALL_SOURCE_ABSENT: WIN32_ERROR = WIN32_ERROR(1612u32);
pub const ERROR_INSTALL_PACKAGE_VERSION: WIN32_ERROR = WIN32_ERROR(1613u32);
pub const ERROR_PRODUCT_UNINSTALLED: WIN32_ERROR = WIN32_ERROR(1614u32);
pub const ERROR_BAD_QUERY_SYNTAX: WIN32_ERROR = WIN32_ERROR(1615u32);
pub const ERROR_INVALID_FIELD: WIN32_ERROR = WIN32_ERROR(1616u32);
pub const ERROR_DEVICE_REMOVED: WIN32_ERROR = WIN32_ERROR(1617u32);
pub const ERROR_INSTALL_ALREADY_RUNNING: WIN32_ERROR = WIN32_ERROR(1618u32);
pub const ERROR_INSTALL_PACKAGE_OPEN_FAILED: WIN32_ERROR = WIN32_ERROR(1619u32);
pub const ERROR_INSTALL_PACKAGE_INVALID: WIN32_ERROR = WIN32_ERROR(1620u32);
pub const ERROR_INSTALL_UI_FAILURE: WIN32_ERROR = WIN32_ERROR(1621u32);
pub const ERROR_INSTALL_LOG_FAILURE: WIN32_ERROR = WIN32_ERROR(1622u32);
pub const ERROR_INSTALL_LANGUAGE_UNSUPPORTED: WIN32_ERROR = WIN32_ERROR(1623u32);
pub const ERROR_INSTALL_TRANSFORM_FAILURE: WIN32_ERROR = WIN32_ERROR(1624u32);
pub const ERROR_INSTALL_PACKAGE_REJECTED: WIN32_ERROR = WIN32_ERROR(1625u32);
pub const ERROR_FUNCTION_NOT_CALLED: WIN32_ERROR = WIN32_ERROR(1626u32);
pub const ERROR_FUNCTION_FAILED: WIN32_ERROR = WIN32_ERROR(1627u32);
pub const ERROR_INVALID_TABLE: WIN32_ERROR = WIN32_ERROR(1628u32);
pub const ERROR_DATATYPE_MISMATCH: WIN32_ERROR = WIN32_ERROR(1629u32);
pub const ERROR_UNSUPPORTED_TYPE: WIN32_ERROR = WIN32_ERROR(1630u32);
pub const ERROR_CREATE_FAILED: WIN32_ERROR = WIN32_ERROR(1631u32);
pub const ERROR_INSTALL_TEMP_UNWRITABLE: WIN32_ERROR = WIN32_ERROR(1632u32);
pub const ERROR_INSTALL_PLATFORM_UNSUPPORTED: WIN32_ERROR = WIN32_ERROR(1633u32);
pub const ERROR_INSTALL_NOTUSED: WIN32_ERROR = WIN32_ERROR(1634u32);
pub const ERROR_PATCH_PACKAGE_OPEN_FAILED: WIN32_ERROR = WIN32_ERROR(1635u32);
pub const ERROR_PATCH_PACKAGE_INVALID: WIN32_ERROR = WIN32_ERROR(1636u32);
pub const ERROR_PATCH_PACKAGE_UNSUPPORTED: WIN32_ERROR = WIN32_ERROR(1637u32);
pub const ERROR_PRODUCT_VERSION: WIN32_ERROR = WIN32_ERROR(1638u32);
pub const ERROR_INVALID_COMMAND_LINE: WIN32_ERROR = WIN32_ERROR(1639u32);
pub const ERROR_INSTALL_REMOTE_DISALLOWED: WIN32_ERROR = WIN32_ERROR(1640u32);
pub const ERROR_SUCCESS_REBOOT_INITIATED: WIN32_ERROR = WIN32_ERROR(1641u32);
pub const ERROR_PATCH_TARGET_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1642u32);
pub const ERROR_PATCH_PACKAGE_REJECTED: WIN32_ERROR = WIN32_ERROR(1643u32);
pub const ERROR_INSTALL_TRANSFORM_REJECTED: WIN32_ERROR = WIN32_ERROR(1644u32);
pub const ERROR_INSTALL_REMOTE_PROHIBITED: WIN32_ERROR = WIN32_ERROR(1645u32);
pub const ERROR_PATCH_REMOVAL_UNSUPPORTED: WIN32_ERROR = WIN32_ERROR(1646u32);
pub const ERROR_UNKNOWN_PATCH: WIN32_ERROR = WIN32_ERROR(1647u32);
pub const ERROR_PATCH_NO_SEQUENCE: WIN32_ERROR = WIN32_ERROR(1648u32);
pub const ERROR_PATCH_REMOVAL_DISALLOWED: WIN32_ERROR = WIN32_ERROR(1649u32);
pub const ERROR_INVALID_PATCH_XML: WIN32_ERROR = WIN32_ERROR(1650u32);
pub const ERROR_PATCH_MANAGED_ADVERTISED_PRODUCT: WIN32_ERROR = WIN32_ERROR(1651u32);
pub const ERROR_INSTALL_SERVICE_SAFEBOOT: WIN32_ERROR = WIN32_ERROR(1652u32);
pub const ERROR_FAIL_FAST_EXCEPTION: WIN32_ERROR = WIN32_ERROR(1653u32);
pub const ERROR_INSTALL_REJECTED: WIN32_ERROR = WIN32_ERROR(1654u32);
pub const ERROR_DYNAMIC_CODE_BLOCKED: WIN32_ERROR = WIN32_ERROR(1655u32);
pub const ERROR_NOT_SAME_OBJECT: WIN32_ERROR = WIN32_ERROR(1656u32);
pub const ERROR_STRICT_CFG_VIOLATION: WIN32_ERROR = WIN32_ERROR(1657u32);
pub const ERROR_SET_CONTEXT_DENIED: WIN32_ERROR = WIN32_ERROR(1660u32);
pub const ERROR_CROSS_PARTITION_VIOLATION: WIN32_ERROR = WIN32_ERROR(1661u32);
pub const ERROR_RETURN_ADDRESS_HIJACK_ATTEMPT: WIN32_ERROR = WIN32_ERROR(1662u32);
pub const ERROR_INVALID_USER_BUFFER: WIN32_ERROR = WIN32_ERROR(1784u32);
pub const ERROR_UNRECOGNIZED_MEDIA: WIN32_ERROR = WIN32_ERROR(1785u32);
pub const ERROR_NO_TRUST_LSA_SECRET: WIN32_ERROR = WIN32_ERROR(1786u32);
pub const ERROR_NO_TRUST_SAM_ACCOUNT: WIN32_ERROR = WIN32_ERROR(1787u32);
pub const ERROR_TRUSTED_DOMAIN_FAILURE: WIN32_ERROR = WIN32_ERROR(1788u32);
pub const ERROR_TRUSTED_RELATIONSHIP_FAILURE: WIN32_ERROR = WIN32_ERROR(1789u32);
pub const ERROR_TRUST_FAILURE: WIN32_ERROR = WIN32_ERROR(1790u32);
pub const ERROR_NETLOGON_NOT_STARTED: WIN32_ERROR = WIN32_ERROR(1792u32);
pub const ERROR_ACCOUNT_EXPIRED: WIN32_ERROR = WIN32_ERROR(1793u32);
pub const ERROR_REDIRECTOR_HAS_OPEN_HANDLES: WIN32_ERROR = WIN32_ERROR(1794u32);
pub const ERROR_PRINTER_DRIVER_ALREADY_INSTALLED: WIN32_ERROR = WIN32_ERROR(1795u32);
pub const ERROR_UNKNOWN_PORT: WIN32_ERROR = WIN32_ERROR(1796u32);
pub const ERROR_UNKNOWN_PRINTER_DRIVER: WIN32_ERROR = WIN32_ERROR(1797u32);
pub const ERROR_UNKNOWN_PRINTPROCESSOR: WIN32_ERROR = WIN32_ERROR(1798u32);
pub const ERROR_INVALID_SEPARATOR_FILE: WIN32_ERROR = WIN32_ERROR(1799u32);
pub const ERROR_INVALID_PRIORITY: WIN32_ERROR = WIN32_ERROR(1800u32);
pub const ERROR_INVALID_PRINTER_NAME: WIN32_ERROR = WIN32_ERROR(1801u32);
pub const ERROR_PRINTER_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(1802u32);
pub const ERROR_INVALID_PRINTER_COMMAND: WIN32_ERROR = WIN32_ERROR(1803u32);
pub const ERROR_INVALID_DATATYPE: WIN32_ERROR = WIN32_ERROR(1804u32);
pub const ERROR_INVALID_ENVIRONMENT: WIN32_ERROR = WIN32_ERROR(1805u32);
pub const ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT: WIN32_ERROR = WIN32_ERROR(1807u32);
pub const ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT: WIN32_ERROR = WIN32_ERROR(1808u32);
pub const ERROR_NOLOGON_SERVER_TRUST_ACCOUNT: WIN32_ERROR = WIN32_ERROR(1809u32);
pub const ERROR_DOMAIN_TRUST_INCONSISTENT: WIN32_ERROR = WIN32_ERROR(1810u32);
pub const ERROR_SERVER_HAS_OPEN_HANDLES: WIN32_ERROR = WIN32_ERROR(1811u32);
pub const ERROR_RESOURCE_DATA_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1812u32);
pub const ERROR_RESOURCE_TYPE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1813u32);
pub const ERROR_RESOURCE_NAME_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1814u32);
pub const ERROR_RESOURCE_LANG_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1815u32);
pub const ERROR_NOT_ENOUGH_QUOTA: WIN32_ERROR = WIN32_ERROR(1816u32);
pub const ERROR_INVALID_TIME: WIN32_ERROR = WIN32_ERROR(1901u32);
pub const ERROR_INVALID_FORM_NAME: WIN32_ERROR = WIN32_ERROR(1902u32);
pub const ERROR_INVALID_FORM_SIZE: WIN32_ERROR = WIN32_ERROR(1903u32);
pub const ERROR_ALREADY_WAITING: WIN32_ERROR = WIN32_ERROR(1904u32);
pub const ERROR_PRINTER_DELETED: WIN32_ERROR = WIN32_ERROR(1905u32);
pub const ERROR_INVALID_PRINTER_STATE: WIN32_ERROR = WIN32_ERROR(1906u32);
pub const ERROR_PASSWORD_MUST_CHANGE: WIN32_ERROR = WIN32_ERROR(1907u32);
pub const ERROR_DOMAIN_CONTROLLER_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(1908u32);
pub const ERROR_ACCOUNT_LOCKED_OUT: WIN32_ERROR = WIN32_ERROR(1909u32);
pub const ERROR_NO_SITENAME: WIN32_ERROR = WIN32_ERROR(1919u32);
pub const ERROR_CANT_ACCESS_FILE: WIN32_ERROR = WIN32_ERROR(1920u32);
pub const ERROR_CANT_RESOLVE_FILENAME: WIN32_ERROR = WIN32_ERROR(1921u32);
pub const ERROR_KM_DRIVER_BLOCKED: WIN32_ERROR = WIN32_ERROR(1930u32);
pub const ERROR_CONTEXT_EXPIRED: WIN32_ERROR = WIN32_ERROR(1931u32);
pub const ERROR_PER_USER_TRUST_QUOTA_EXCEEDED: WIN32_ERROR = WIN32_ERROR(1932u32);
pub const ERROR_ALL_USER_TRUST_QUOTA_EXCEEDED: WIN32_ERROR = WIN32_ERROR(1933u32);
pub const ERROR_USER_DELETE_TRUST_QUOTA_EXCEEDED: WIN32_ERROR = WIN32_ERROR(1934u32);
pub const ERROR_AUTHENTICATION_FIREWALL_FAILED: WIN32_ERROR = WIN32_ERROR(1935u32);
pub const ERROR_REMOTE_PRINT_CONNECTIONS_BLOCKED: WIN32_ERROR = WIN32_ERROR(1936u32);
pub const ERROR_NTLM_BLOCKED: WIN32_ERROR = WIN32_ERROR(1937u32);
pub const ERROR_PASSWORD_CHANGE_REQUIRED: WIN32_ERROR = WIN32_ERROR(1938u32);
pub const ERROR_LOST_MODE_LOGON_RESTRICTION: WIN32_ERROR = WIN32_ERROR(1939u32);
pub const ERROR_INVALID_PIXEL_FORMAT: WIN32_ERROR = WIN32_ERROR(2000u32);
pub const ERROR_BAD_DRIVER: WIN32_ERROR = WIN32_ERROR(2001u32);
pub const ERROR_INVALID_WINDOW_STYLE: WIN32_ERROR = WIN32_ERROR(2002u32);
pub const ERROR_METAFILE_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(2003u32);
pub const ERROR_TRANSFORM_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(2004u32);
pub const ERROR_CLIPPING_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(2005u32);
pub const ERROR_INVALID_CMM: WIN32_ERROR = WIN32_ERROR(2010u32);
pub const ERROR_INVALID_PROFILE: WIN32_ERROR = WIN32_ERROR(2011u32);
pub const ERROR_TAG_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(2012u32);
pub const ERROR_TAG_NOT_PRESENT: WIN32_ERROR = WIN32_ERROR(2013u32);
pub const ERROR_DUPLICATE_TAG: WIN32_ERROR = WIN32_ERROR(2014u32);
pub const ERROR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE: WIN32_ERROR = WIN32_ERROR(2015u32);
pub const ERROR_PROFILE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(2016u32);
pub const ERROR_INVALID_COLORSPACE: WIN32_ERROR = WIN32_ERROR(2017u32);
pub const ERROR_ICM_NOT_ENABLED: WIN32_ERROR = WIN32_ERROR(2018u32);
pub const ERROR_DELETING_ICM_XFORM: WIN32_ERROR = WIN32_ERROR(2019u32);
pub const ERROR_INVALID_TRANSFORM: WIN32_ERROR = WIN32_ERROR(2020u32);
pub const ERROR_COLORSPACE_MISMATCH: WIN32_ERROR = WIN32_ERROR(2021u32);
pub const ERROR_INVALID_COLORINDEX: WIN32_ERROR = WIN32_ERROR(2022u32);
pub const ERROR_PROFILE_DOES_NOT_MATCH_DEVICE: WIN32_ERROR = WIN32_ERROR(2023u32);
pub const ERROR_CONNECTED_OTHER_PASSWORD: WIN32_ERROR = WIN32_ERROR(2108u32);
pub const ERROR_CONNECTED_OTHER_PASSWORD_DEFAULT: WIN32_ERROR = WIN32_ERROR(2109u32);
pub const ERROR_BAD_USERNAME: WIN32_ERROR = WIN32_ERROR(2202u32);
pub const ERROR_NOT_CONNECTED: WIN32_ERROR = WIN32_ERROR(2250u32);
pub const ERROR_OPEN_FILES: WIN32_ERROR = WIN32_ERROR(2401u32);
pub const ERROR_ACTIVE_CONNECTIONS: WIN32_ERROR = WIN32_ERROR(2402u32);
pub const ERROR_DEVICE_IN_USE: WIN32_ERROR = WIN32_ERROR(2404u32);
pub const ERROR_UNKNOWN_PRINT_MONITOR: WIN32_ERROR = WIN32_ERROR(3000u32);
pub const ERROR_PRINTER_DRIVER_IN_USE: WIN32_ERROR = WIN32_ERROR(3001u32);
pub const ERROR_SPOOL_FILE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(3002u32);
pub const ERROR_SPL_NO_STARTDOC: WIN32_ERROR = WIN32_ERROR(3003u32);
pub const ERROR_SPL_NO_ADDJOB: WIN32_ERROR = WIN32_ERROR(3004u32);
pub const ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED: WIN32_ERROR = WIN32_ERROR(3005u32);
pub const ERROR_PRINT_MONITOR_ALREADY_INSTALLED: WIN32_ERROR = WIN32_ERROR(3006u32);
pub const ERROR_INVALID_PRINT_MONITOR: WIN32_ERROR = WIN32_ERROR(3007u32);
pub const ERROR_PRINT_MONITOR_IN_USE: WIN32_ERROR = WIN32_ERROR(3008u32);
pub const ERROR_PRINTER_HAS_JOBS_QUEUED: WIN32_ERROR = WIN32_ERROR(3009u32);
pub const ERROR_SUCCESS_REBOOT_REQUIRED: WIN32_ERROR = WIN32_ERROR(3010u32);
pub const ERROR_SUCCESS_RESTART_REQUIRED: WIN32_ERROR = WIN32_ERROR(3011u32);
pub const ERROR_PRINTER_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(3012u32);
pub const ERROR_PRINTER_DRIVER_WARNED: WIN32_ERROR = WIN32_ERROR(3013u32);
pub const ERROR_PRINTER_DRIVER_BLOCKED: WIN32_ERROR = WIN32_ERROR(3014u32);
pub const ERROR_PRINTER_DRIVER_PACKAGE_IN_USE: WIN32_ERROR = WIN32_ERROR(3015u32);
pub const ERROR_CORE_DRIVER_PACKAGE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(3016u32);
pub const ERROR_FAIL_REBOOT_REQUIRED: WIN32_ERROR = WIN32_ERROR(3017u32);
pub const ERROR_FAIL_REBOOT_INITIATED: WIN32_ERROR = WIN32_ERROR(3018u32);
pub const ERROR_PRINTER_DRIVER_DOWNLOAD_NEEDED: WIN32_ERROR = WIN32_ERROR(3019u32);
pub const ERROR_PRINT_JOB_RESTART_REQUIRED: WIN32_ERROR = WIN32_ERROR(3020u32);
pub const ERROR_INVALID_PRINTER_DRIVER_MANIFEST: WIN32_ERROR = WIN32_ERROR(3021u32);
pub const ERROR_PRINTER_NOT_SHAREABLE: WIN32_ERROR = WIN32_ERROR(3022u32);
pub const ERROR_REQUEST_PAUSED: WIN32_ERROR = WIN32_ERROR(3050u32);
pub const ERROR_APPEXEC_CONDITION_NOT_SATISFIED: WIN32_ERROR = WIN32_ERROR(3060u32);
pub const ERROR_APPEXEC_HANDLE_INVALIDATED: WIN32_ERROR = WIN32_ERROR(3061u32);
pub const ERROR_APPEXEC_INVALID_HOST_GENERATION: WIN32_ERROR = WIN32_ERROR(3062u32);
pub const ERROR_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION: WIN32_ERROR = WIN32_ERROR(3063u32);
pub const ERROR_APPEXEC_INVALID_HOST_STATE: WIN32_ERROR = WIN32_ERROR(3064u32);
pub const ERROR_APPEXEC_NO_DONOR: WIN32_ERROR = WIN32_ERROR(3065u32);
pub const ERROR_APPEXEC_HOST_ID_MISMATCH: WIN32_ERROR = WIN32_ERROR(3066u32);
pub const ERROR_APPEXEC_UNKNOWN_USER: WIN32_ERROR = WIN32_ERROR(3067u32);
pub const ERROR_APPEXEC_APP_COMPAT_BLOCK: WIN32_ERROR = WIN32_ERROR(3068u32);
pub const ERROR_APPEXEC_CALLER_WAIT_TIMEOUT: WIN32_ERROR = WIN32_ERROR(3069u32);
pub const ERROR_APPEXEC_CALLER_WAIT_TIMEOUT_TERMINATION: WIN32_ERROR = WIN32_ERROR(3070u32);
pub const ERROR_APPEXEC_CALLER_WAIT_TIMEOUT_LICENSING: WIN32_ERROR = WIN32_ERROR(3071u32);
pub const ERROR_APPEXEC_CALLER_WAIT_TIMEOUT_RESOURCES: WIN32_ERROR = WIN32_ERROR(3072u32);
pub const ERROR_VRF_VOLATILE_CFG_AND_IO_ENABLED: WIN32_ERROR = WIN32_ERROR(3080u32);
pub const ERROR_VRF_VOLATILE_NOT_STOPPABLE: WIN32_ERROR = WIN32_ERROR(3081u32);
pub const ERROR_VRF_VOLATILE_SAFE_MODE: WIN32_ERROR = WIN32_ERROR(3082u32);
pub const ERROR_VRF_VOLATILE_NOT_RUNNABLE_SYSTEM: WIN32_ERROR = WIN32_ERROR(3083u32);
pub const ERROR_VRF_VOLATILE_NOT_SUPPORTED_RULECLASS: WIN32_ERROR = WIN32_ERROR(3084u32);
pub const ERROR_VRF_VOLATILE_PROTECTED_DRIVER: WIN32_ERROR = WIN32_ERROR(3085u32);
pub const ERROR_VRF_VOLATILE_NMI_REGISTERED: WIN32_ERROR = WIN32_ERROR(3086u32);
pub const ERROR_VRF_VOLATILE_SETTINGS_CONFLICT: WIN32_ERROR = WIN32_ERROR(3087u32);
pub const ERROR_DIF_IOCALLBACK_NOT_REPLACED: WIN32_ERROR = WIN32_ERROR(3190u32);
pub const ERROR_DIF_LIVEDUMP_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(3191u32);
pub const ERROR_DIF_VOLATILE_SECTION_NOT_LOCKED: WIN32_ERROR = WIN32_ERROR(3192u32);
pub const ERROR_DIF_VOLATILE_DRIVER_HOTPATCHED: WIN32_ERROR = WIN32_ERROR(3193u32);
pub const ERROR_DIF_VOLATILE_INVALID_INFO: WIN32_ERROR = WIN32_ERROR(3194u32);
pub const ERROR_DIF_VOLATILE_DRIVER_IS_NOT_RUNNING: WIN32_ERROR = WIN32_ERROR(3195u32);
pub const ERROR_DIF_VOLATILE_PLUGIN_IS_NOT_RUNNING: WIN32_ERROR = WIN32_ERROR(3196u32);
pub const ERROR_DIF_VOLATILE_PLUGIN_CHANGE_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(3197u32);
pub const ERROR_DIF_VOLATILE_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(3198u32);
pub const ERROR_DIF_BINDING_API_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(3199u32);
pub const ERROR_IO_REISSUE_AS_CACHED: WIN32_ERROR = WIN32_ERROR(3950u32);
pub const ERROR_WINS_INTERNAL: WIN32_ERROR = WIN32_ERROR(4000u32);
pub const ERROR_CAN_NOT_DEL_LOCAL_WINS: WIN32_ERROR = WIN32_ERROR(4001u32);
pub const ERROR_STATIC_INIT: WIN32_ERROR = WIN32_ERROR(4002u32);
pub const ERROR_INC_BACKUP: WIN32_ERROR = WIN32_ERROR(4003u32);
pub const ERROR_FULL_BACKUP: WIN32_ERROR = WIN32_ERROR(4004u32);
pub const ERROR_REC_NON_EXISTENT: WIN32_ERROR = WIN32_ERROR(4005u32);
pub const ERROR_RPL_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(4006u32);
pub const ERROR_DHCP_ADDRESS_CONFLICT: WIN32_ERROR = WIN32_ERROR(4100u32);
pub const ERROR_WMI_GUID_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(4200u32);
pub const ERROR_WMI_INSTANCE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(4201u32);
pub const ERROR_WMI_ITEMID_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(4202u32);
pub const ERROR_WMI_TRY_AGAIN: WIN32_ERROR = WIN32_ERROR(4203u32);
pub const ERROR_WMI_DP_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(4204u32);
pub const ERROR_WMI_UNRESOLVED_INSTANCE_REF: WIN32_ERROR = WIN32_ERROR(4205u32);
pub const ERROR_WMI_ALREADY_ENABLED: WIN32_ERROR = WIN32_ERROR(4206u32);
pub const ERROR_WMI_GUID_DISCONNECTED: WIN32_ERROR = WIN32_ERROR(4207u32);
pub const ERROR_WMI_SERVER_UNAVAILABLE: WIN32_ERROR = WIN32_ERROR(4208u32);
pub const ERROR_WMI_DP_FAILED: WIN32_ERROR = WIN32_ERROR(4209u32);
pub const ERROR_WMI_INVALID_MOF: WIN32_ERROR = WIN32_ERROR(4210u32);
pub const ERROR_WMI_INVALID_REGINFO: WIN32_ERROR = WIN32_ERROR(4211u32);
pub const ERROR_WMI_ALREADY_DISABLED: WIN32_ERROR = WIN32_ERROR(4212u32);
pub const ERROR_WMI_READ_ONLY: WIN32_ERROR = WIN32_ERROR(4213u32);
pub const ERROR_WMI_SET_FAILURE: WIN32_ERROR = WIN32_ERROR(4214u32);
pub const ERROR_NOT_APPCONTAINER: WIN32_ERROR = WIN32_ERROR(4250u32);
pub const ERROR_APPCONTAINER_REQUIRED: WIN32_ERROR = WIN32_ERROR(4251u32);
pub const ERROR_NOT_SUPPORTED_IN_APPCONTAINER: WIN32_ERROR = WIN32_ERROR(4252u32);
pub const ERROR_INVALID_PACKAGE_SID_LENGTH: WIN32_ERROR = WIN32_ERROR(4253u32);
pub const ERROR_INVALID_MEDIA: WIN32_ERROR = WIN32_ERROR(4300u32);
pub const ERROR_INVALID_LIBRARY: WIN32_ERROR = WIN32_ERROR(4301u32);
pub const ERROR_INVALID_MEDIA_POOL: WIN32_ERROR = WIN32_ERROR(4302u32);
pub const ERROR_DRIVE_MEDIA_MISMATCH: WIN32_ERROR = WIN32_ERROR(4303u32);
pub const ERROR_MEDIA_OFFLINE: WIN32_ERROR = WIN32_ERROR(4304u32);
pub const ERROR_LIBRARY_OFFLINE: WIN32_ERROR = WIN32_ERROR(4305u32);
pub const ERROR_EMPTY: WIN32_ERROR = WIN32_ERROR(4306u32);
pub const ERROR_NOT_EMPTY: WIN32_ERROR = WIN32_ERROR(4307u32);
pub const ERROR_MEDIA_UNAVAILABLE: WIN32_ERROR = WIN32_ERROR(4308u32);
pub const ERROR_RESOURCE_DISABLED: WIN32_ERROR = WIN32_ERROR(4309u32);
pub const ERROR_INVALID_CLEANER: WIN32_ERROR = WIN32_ERROR(4310u32);
pub const ERROR_UNABLE_TO_CLEAN: WIN32_ERROR = WIN32_ERROR(4311u32);
pub const ERROR_OBJECT_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(4312u32);
pub const ERROR_DATABASE_FAILURE: WIN32_ERROR = WIN32_ERROR(4313u32);
pub const ERROR_DATABASE_FULL: WIN32_ERROR = WIN32_ERROR(4314u32);
pub const ERROR_MEDIA_INCOMPATIBLE: WIN32_ERROR = WIN32_ERROR(4315u32);
pub const ERROR_RESOURCE_NOT_PRESENT: WIN32_ERROR = WIN32_ERROR(4316u32);
pub const ERROR_INVALID_OPERATION: WIN32_ERROR = WIN32_ERROR(4317u32);
pub const ERROR_MEDIA_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(4318u32);
pub const ERROR_DEVICE_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(4319u32);
pub const ERROR_REQUEST_REFUSED: WIN32_ERROR = WIN32_ERROR(4320u32);
pub const ERROR_INVALID_DRIVE_OBJECT: WIN32_ERROR = WIN32_ERROR(4321u32);
pub const ERROR_LIBRARY_FULL: WIN32_ERROR = WIN32_ERROR(4322u32);
pub const ERROR_MEDIUM_NOT_ACCESSIBLE: WIN32_ERROR = WIN32_ERROR(4323u32);
pub const ERROR_UNABLE_TO_LOAD_MEDIUM: WIN32_ERROR = WIN32_ERROR(4324u32);
pub const ERROR_UNABLE_TO_INVENTORY_DRIVE: WIN32_ERROR = WIN32_ERROR(4325u32);
pub const ERROR_UNABLE_TO_INVENTORY_SLOT: WIN32_ERROR = WIN32_ERROR(4326u32);
pub const ERROR_UNABLE_TO_INVENTORY_TRANSPORT: WIN32_ERROR = WIN32_ERROR(4327u32);
pub const ERROR_TRANSPORT_FULL: WIN32_ERROR = WIN32_ERROR(4328u32);
pub const ERROR_CONTROLLING_IEPORT: WIN32_ERROR = WIN32_ERROR(4329u32);
pub const ERROR_UNABLE_TO_EJECT_MOUNTED_MEDIA: WIN32_ERROR = WIN32_ERROR(4330u32);
pub const ERROR_CLEANER_SLOT_SET: WIN32_ERROR = WIN32_ERROR(4331u32);
pub const ERROR_CLEANER_SLOT_NOT_SET: WIN32_ERROR = WIN32_ERROR(4332u32);
pub const ERROR_CLEANER_CARTRIDGE_SPENT: WIN32_ERROR = WIN32_ERROR(4333u32);
pub const ERROR_UNEXPECTED_OMID: WIN32_ERROR = WIN32_ERROR(4334u32);
pub const ERROR_CANT_DELETE_LAST_ITEM: WIN32_ERROR = WIN32_ERROR(4335u32);
pub const ERROR_MESSAGE_EXCEEDS_MAX_SIZE: WIN32_ERROR = WIN32_ERROR(4336u32);
pub const ERROR_VOLUME_CONTAINS_SYS_FILES: WIN32_ERROR = WIN32_ERROR(4337u32);
pub const ERROR_INDIGENOUS_TYPE: WIN32_ERROR = WIN32_ERROR(4338u32);
pub const ERROR_NO_SUPPORTING_DRIVES: WIN32_ERROR = WIN32_ERROR(4339u32);
pub const ERROR_CLEANER_CARTRIDGE_INSTALLED: WIN32_ERROR = WIN32_ERROR(4340u32);
pub const ERROR_IEPORT_FULL: WIN32_ERROR = WIN32_ERROR(4341u32);
pub const ERROR_FILE_OFFLINE: WIN32_ERROR = WIN32_ERROR(4350u32);
pub const ERROR_REMOTE_STORAGE_NOT_ACTIVE: WIN32_ERROR = WIN32_ERROR(4351u32);
pub const ERROR_REMOTE_STORAGE_MEDIA_ERROR: WIN32_ERROR = WIN32_ERROR(4352u32);
pub const ERROR_NOT_A_REPARSE_POINT: WIN32_ERROR = WIN32_ERROR(4390u32);
pub const ERROR_REPARSE_ATTRIBUTE_CONFLICT: WIN32_ERROR = WIN32_ERROR(4391u32);
pub const ERROR_INVALID_REPARSE_DATA: WIN32_ERROR = WIN32_ERROR(4392u32);
pub const ERROR_REPARSE_TAG_INVALID: WIN32_ERROR = WIN32_ERROR(4393u32);
pub const ERROR_REPARSE_TAG_MISMATCH: WIN32_ERROR = WIN32_ERROR(4394u32);
pub const ERROR_REPARSE_POINT_ENCOUNTERED: WIN32_ERROR = WIN32_ERROR(4395u32);
pub const ERROR_APP_DATA_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(4400u32);
pub const ERROR_APP_DATA_EXPIRED: WIN32_ERROR = WIN32_ERROR(4401u32);
pub const ERROR_APP_DATA_CORRUPT: WIN32_ERROR = WIN32_ERROR(4402u32);
pub const ERROR_APP_DATA_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(4403u32);
pub const ERROR_APP_DATA_REBOOT_REQUIRED: WIN32_ERROR = WIN32_ERROR(4404u32);
pub const ERROR_SECUREBOOT_ROLLBACK_DETECTED: WIN32_ERROR = WIN32_ERROR(4420u32);
pub const ERROR_SECUREBOOT_POLICY_VIOLATION: WIN32_ERROR = WIN32_ERROR(4421u32);
pub const ERROR_SECUREBOOT_INVALID_POLICY: WIN32_ERROR = WIN32_ERROR(4422u32);
pub const ERROR_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(4423u32);
pub const ERROR_SECUREBOOT_POLICY_NOT_SIGNED: WIN32_ERROR = WIN32_ERROR(4424u32);
pub const ERROR_SECUREBOOT_NOT_ENABLED: WIN32_ERROR = WIN32_ERROR(4425u32);
pub const ERROR_SECUREBOOT_FILE_REPLACED: WIN32_ERROR = WIN32_ERROR(4426u32);
pub const ERROR_SECUREBOOT_POLICY_NOT_AUTHORIZED: WIN32_ERROR = WIN32_ERROR(4427u32);
pub const ERROR_SECUREBOOT_POLICY_UNKNOWN: WIN32_ERROR = WIN32_ERROR(4428u32);
pub const ERROR_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION: WIN32_ERROR = WIN32_ERROR(4429u32);
pub const ERROR_SECUREBOOT_PLATFORM_ID_MISMATCH: WIN32_ERROR = WIN32_ERROR(4430u32);
pub const ERROR_SECUREBOOT_POLICY_ROLLBACK_DETECTED: WIN32_ERROR = WIN32_ERROR(4431u32);
pub const ERROR_SECUREBOOT_POLICY_UPGRADE_MISMATCH: WIN32_ERROR = WIN32_ERROR(4432u32);
pub const ERROR_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING: WIN32_ERROR = WIN32_ERROR(4433u32);
pub const ERROR_SECUREBOOT_NOT_BASE_POLICY: WIN32_ERROR = WIN32_ERROR(4434u32);
pub const ERROR_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY: WIN32_ERROR = WIN32_ERROR(4435u32);
pub const ERROR_OFFLOAD_READ_FLT_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(4440u32);
pub const ERROR_OFFLOAD_WRITE_FLT_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(4441u32);
pub const ERROR_OFFLOAD_READ_FILE_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(4442u32);
pub const ERROR_OFFLOAD_WRITE_FILE_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(4443u32);
pub const ERROR_ALREADY_HAS_STREAM_ID: WIN32_ERROR = WIN32_ERROR(4444u32);
pub const ERROR_SMR_GARBAGE_COLLECTION_REQUIRED: WIN32_ERROR = WIN32_ERROR(4445u32);
pub const ERROR_WOF_WIM_HEADER_CORRUPT: WIN32_ERROR = WIN32_ERROR(4446u32);
pub const ERROR_WOF_WIM_RESOURCE_TABLE_CORRUPT: WIN32_ERROR = WIN32_ERROR(4447u32);
pub const ERROR_WOF_FILE_RESOURCE_TABLE_CORRUPT: WIN32_ERROR = WIN32_ERROR(4448u32);
pub const ERROR_OBJECT_IS_IMMUTABLE: WIN32_ERROR = WIN32_ERROR(4449u32);
pub const ERROR_VOLUME_NOT_SIS_ENABLED: WIN32_ERROR = WIN32_ERROR(4500u32);
pub const ERROR_SYSTEM_INTEGRITY_ROLLBACK_DETECTED: WIN32_ERROR = WIN32_ERROR(4550u32);
pub const ERROR_SYSTEM_INTEGRITY_POLICY_VIOLATION: WIN32_ERROR = WIN32_ERROR(4551u32);
pub const ERROR_SYSTEM_INTEGRITY_INVALID_POLICY: WIN32_ERROR = WIN32_ERROR(4552u32);
pub const ERROR_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED: WIN32_ERROR = WIN32_ERROR(4553u32);
pub const ERROR_SYSTEM_INTEGRITY_TOO_MANY_POLICIES: WIN32_ERROR = WIN32_ERROR(4554u32);
pub const ERROR_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED: WIN32_ERROR = WIN32_ERROR(4555u32);
pub const ERROR_SYSTEM_INTEGRITY_REPUTATION_MALICIOUS: WIN32_ERROR = WIN32_ERROR(4556u32);
pub const ERROR_SYSTEM_INTEGRITY_REPUTATION_PUA: WIN32_ERROR = WIN32_ERROR(4557u32);
pub const ERROR_SYSTEM_INTEGRITY_REPUTATION_DANGEROUS_EXT: WIN32_ERROR = WIN32_ERROR(4558u32);
pub const ERROR_SYSTEM_INTEGRITY_REPUTATION_OFFLINE: WIN32_ERROR = WIN32_ERROR(4559u32);
pub const ERROR_VSM_NOT_INITIALIZED: WIN32_ERROR = WIN32_ERROR(4560u32);
pub const ERROR_VSM_DMA_PROTECTION_NOT_IN_USE: WIN32_ERROR = WIN32_ERROR(4561u32);
pub const ERROR_PLATFORM_MANIFEST_NOT_AUTHORIZED: WIN32_ERROR = WIN32_ERROR(4570u32);
pub const ERROR_PLATFORM_MANIFEST_INVALID: WIN32_ERROR = WIN32_ERROR(4571u32);
pub const ERROR_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED: WIN32_ERROR = WIN32_ERROR(4572u32);
pub const ERROR_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED: WIN32_ERROR = WIN32_ERROR(4573u32);
pub const ERROR_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(4574u32);
pub const ERROR_PLATFORM_MANIFEST_NOT_ACTIVE: WIN32_ERROR = WIN32_ERROR(4575u32);
pub const ERROR_PLATFORM_MANIFEST_NOT_SIGNED: WIN32_ERROR = WIN32_ERROR(4576u32);
pub const ERROR_DEPENDENT_RESOURCE_EXISTS: WIN32_ERROR = WIN32_ERROR(5001u32);
pub const ERROR_DEPENDENCY_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5002u32);
pub const ERROR_DEPENDENCY_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(5003u32);
pub const ERROR_RESOURCE_NOT_ONLINE: WIN32_ERROR = WIN32_ERROR(5004u32);
pub const ERROR_HOST_NODE_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(5005u32);
pub const ERROR_RESOURCE_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(5006u32);
pub const ERROR_RESOURCE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5007u32);
pub const ERROR_SHUTDOWN_CLUSTER: WIN32_ERROR = WIN32_ERROR(5008u32);
pub const ERROR_CANT_EVICT_ACTIVE_NODE: WIN32_ERROR = WIN32_ERROR(5009u32);
pub const ERROR_OBJECT_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(5010u32);
pub const ERROR_OBJECT_IN_LIST: WIN32_ERROR = WIN32_ERROR(5011u32);
pub const ERROR_GROUP_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(5012u32);
pub const ERROR_GROUP_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5013u32);
pub const ERROR_GROUP_NOT_ONLINE: WIN32_ERROR = WIN32_ERROR(5014u32);
pub const ERROR_HOST_NODE_NOT_RESOURCE_OWNER: WIN32_ERROR = WIN32_ERROR(5015u32);
pub const ERROR_HOST_NODE_NOT_GROUP_OWNER: WIN32_ERROR = WIN32_ERROR(5016u32);
pub const ERROR_RESMON_CREATE_FAILED: WIN32_ERROR = WIN32_ERROR(5017u32);
pub const ERROR_RESMON_ONLINE_FAILED: WIN32_ERROR = WIN32_ERROR(5018u32);
pub const ERROR_RESOURCE_ONLINE: WIN32_ERROR = WIN32_ERROR(5019u32);
pub const ERROR_QUORUM_RESOURCE: WIN32_ERROR = WIN32_ERROR(5020u32);
pub const ERROR_NOT_QUORUM_CAPABLE: WIN32_ERROR = WIN32_ERROR(5021u32);
pub const ERROR_CLUSTER_SHUTTING_DOWN: WIN32_ERROR = WIN32_ERROR(5022u32);
pub const ERROR_INVALID_STATE: WIN32_ERROR = WIN32_ERROR(5023u32);
pub const ERROR_RESOURCE_PROPERTIES_STORED: WIN32_ERROR = WIN32_ERROR(5024u32);
pub const ERROR_NOT_QUORUM_CLASS: WIN32_ERROR = WIN32_ERROR(5025u32);
pub const ERROR_CORE_RESOURCE: WIN32_ERROR = WIN32_ERROR(5026u32);
pub const ERROR_QUORUM_RESOURCE_ONLINE_FAILED: WIN32_ERROR = WIN32_ERROR(5027u32);
pub const ERROR_QUORUMLOG_OPEN_FAILED: WIN32_ERROR = WIN32_ERROR(5028u32);
pub const ERROR_CLUSTERLOG_CORRUPT: WIN32_ERROR = WIN32_ERROR(5029u32);
pub const ERROR_CLUSTERLOG_RECORD_EXCEEDS_MAXSIZE: WIN32_ERROR = WIN32_ERROR(5030u32);
pub const ERROR_CLUSTERLOG_EXCEEDS_MAXSIZE: WIN32_ERROR = WIN32_ERROR(5031u32);
pub const ERROR_CLUSTERLOG_CHKPOINT_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5032u32);
pub const ERROR_CLUSTERLOG_NOT_ENOUGH_SPACE: WIN32_ERROR = WIN32_ERROR(5033u32);
pub const ERROR_QUORUM_OWNER_ALIVE: WIN32_ERROR = WIN32_ERROR(5034u32);
pub const ERROR_NETWORK_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(5035u32);
pub const ERROR_NODE_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(5036u32);
pub const ERROR_ALL_NODES_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(5037u32);
pub const ERROR_RESOURCE_FAILED: WIN32_ERROR = WIN32_ERROR(5038u32);
pub const ERROR_CLUSTER_INVALID_NODE: WIN32_ERROR = WIN32_ERROR(5039u32);
pub const ERROR_CLUSTER_NODE_EXISTS: WIN32_ERROR = WIN32_ERROR(5040u32);
pub const ERROR_CLUSTER_JOIN_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(5041u32);
pub const ERROR_CLUSTER_NODE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5042u32);
pub const ERROR_CLUSTER_LOCAL_NODE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5043u32);
pub const ERROR_CLUSTER_NETWORK_EXISTS: WIN32_ERROR = WIN32_ERROR(5044u32);
pub const ERROR_CLUSTER_NETWORK_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5045u32);
pub const ERROR_CLUSTER_NETINTERFACE_EXISTS: WIN32_ERROR = WIN32_ERROR(5046u32);
pub const ERROR_CLUSTER_NETINTERFACE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5047u32);
pub const ERROR_CLUSTER_INVALID_REQUEST: WIN32_ERROR = WIN32_ERROR(5048u32);
pub const ERROR_CLUSTER_INVALID_NETWORK_PROVIDER: WIN32_ERROR = WIN32_ERROR(5049u32);
pub const ERROR_CLUSTER_NODE_DOWN: WIN32_ERROR = WIN32_ERROR(5050u32);
pub const ERROR_CLUSTER_NODE_UNREACHABLE: WIN32_ERROR = WIN32_ERROR(5051u32);
pub const ERROR_CLUSTER_NODE_NOT_MEMBER: WIN32_ERROR = WIN32_ERROR(5052u32);
pub const ERROR_CLUSTER_JOIN_NOT_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(5053u32);
pub const ERROR_CLUSTER_INVALID_NETWORK: WIN32_ERROR = WIN32_ERROR(5054u32);
pub const ERROR_CLUSTER_NODE_UP: WIN32_ERROR = WIN32_ERROR(5056u32);
pub const ERROR_CLUSTER_IPADDR_IN_USE: WIN32_ERROR = WIN32_ERROR(5057u32);
pub const ERROR_CLUSTER_NODE_NOT_PAUSED: WIN32_ERROR = WIN32_ERROR(5058u32);
pub const ERROR_CLUSTER_NO_SECURITY_CONTEXT: WIN32_ERROR = WIN32_ERROR(5059u32);
pub const ERROR_CLUSTER_NETWORK_NOT_INTERNAL: WIN32_ERROR = WIN32_ERROR(5060u32);
pub const ERROR_CLUSTER_NODE_ALREADY_UP: WIN32_ERROR = WIN32_ERROR(5061u32);
pub const ERROR_CLUSTER_NODE_ALREADY_DOWN: WIN32_ERROR = WIN32_ERROR(5062u32);
pub const ERROR_CLUSTER_NETWORK_ALREADY_ONLINE: WIN32_ERROR = WIN32_ERROR(5063u32);
pub const ERROR_CLUSTER_NETWORK_ALREADY_OFFLINE: WIN32_ERROR = WIN32_ERROR(5064u32);
pub const ERROR_CLUSTER_NODE_ALREADY_MEMBER: WIN32_ERROR = WIN32_ERROR(5065u32);
pub const ERROR_CLUSTER_LAST_INTERNAL_NETWORK: WIN32_ERROR = WIN32_ERROR(5066u32);
pub const ERROR_CLUSTER_NETWORK_HAS_DEPENDENTS: WIN32_ERROR = WIN32_ERROR(5067u32);
pub const ERROR_INVALID_OPERATION_ON_QUORUM: WIN32_ERROR = WIN32_ERROR(5068u32);
pub const ERROR_DEPENDENCY_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(5069u32);
pub const ERROR_CLUSTER_NODE_PAUSED: WIN32_ERROR = WIN32_ERROR(5070u32);
pub const ERROR_NODE_CANT_HOST_RESOURCE: WIN32_ERROR = WIN32_ERROR(5071u32);
pub const ERROR_CLUSTER_NODE_NOT_READY: WIN32_ERROR = WIN32_ERROR(5072u32);
pub const ERROR_CLUSTER_NODE_SHUTTING_DOWN: WIN32_ERROR = WIN32_ERROR(5073u32);
pub const ERROR_CLUSTER_JOIN_ABORTED: WIN32_ERROR = WIN32_ERROR(5074u32);
pub const ERROR_CLUSTER_INCOMPATIBLE_VERSIONS: WIN32_ERROR = WIN32_ERROR(5075u32);
pub const ERROR_CLUSTER_MAXNUM_OF_RESOURCES_EXCEEDED: WIN32_ERROR = WIN32_ERROR(5076u32);
pub const ERROR_CLUSTER_SYSTEM_CONFIG_CHANGED: WIN32_ERROR = WIN32_ERROR(5077u32);
pub const ERROR_CLUSTER_RESOURCE_TYPE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5078u32);
pub const ERROR_CLUSTER_RESTYPE_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(5079u32);
pub const ERROR_CLUSTER_RESNAME_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5080u32);
pub const ERROR_CLUSTER_NO_RPC_PACKAGES_REGISTERED: WIN32_ERROR = WIN32_ERROR(5081u32);
pub const ERROR_CLUSTER_OWNER_NOT_IN_PREFLIST: WIN32_ERROR = WIN32_ERROR(5082u32);
pub const ERROR_CLUSTER_DATABASE_SEQMISMATCH: WIN32_ERROR = WIN32_ERROR(5083u32);
pub const ERROR_RESMON_INVALID_STATE: WIN32_ERROR = WIN32_ERROR(5084u32);
pub const ERROR_CLUSTER_GUM_NOT_LOCKER: WIN32_ERROR = WIN32_ERROR(5085u32);
pub const ERROR_QUORUM_DISK_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5086u32);
pub const ERROR_DATABASE_BACKUP_CORRUPT: WIN32_ERROR = WIN32_ERROR(5087u32);
pub const ERROR_CLUSTER_NODE_ALREADY_HAS_DFS_ROOT: WIN32_ERROR = WIN32_ERROR(5088u32);
pub const ERROR_RESOURCE_PROPERTY_UNCHANGEABLE: WIN32_ERROR = WIN32_ERROR(5089u32);
pub const ERROR_NO_ADMIN_ACCESS_POINT: WIN32_ERROR = WIN32_ERROR(5090u32);
pub const ERROR_CLUSTER_MEMBERSHIP_INVALID_STATE: WIN32_ERROR = WIN32_ERROR(5890u32);
pub const ERROR_CLUSTER_QUORUMLOG_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5891u32);
pub const ERROR_CLUSTER_MEMBERSHIP_HALT: WIN32_ERROR = WIN32_ERROR(5892u32);
pub const ERROR_CLUSTER_INSTANCE_ID_MISMATCH: WIN32_ERROR = WIN32_ERROR(5893u32);
pub const ERROR_CLUSTER_NETWORK_NOT_FOUND_FOR_IP: WIN32_ERROR = WIN32_ERROR(5894u32);
pub const ERROR_CLUSTER_PROPERTY_DATA_TYPE_MISMATCH: WIN32_ERROR = WIN32_ERROR(5895u32);
pub const ERROR_CLUSTER_EVICT_WITHOUT_CLEANUP: WIN32_ERROR = WIN32_ERROR(5896u32);
pub const ERROR_CLUSTER_PARAMETER_MISMATCH: WIN32_ERROR = WIN32_ERROR(5897u32);
pub const ERROR_NODE_CANNOT_BE_CLUSTERED: WIN32_ERROR = WIN32_ERROR(5898u32);
pub const ERROR_CLUSTER_WRONG_OS_VERSION: WIN32_ERROR = WIN32_ERROR(5899u32);
pub const ERROR_CLUSTER_CANT_CREATE_DUP_CLUSTER_NAME: WIN32_ERROR = WIN32_ERROR(5900u32);
pub const ERROR_CLUSCFG_ALREADY_COMMITTED: WIN32_ERROR = WIN32_ERROR(5901u32);
pub const ERROR_CLUSCFG_ROLLBACK_FAILED: WIN32_ERROR = WIN32_ERROR(5902u32);
pub const ERROR_CLUSCFG_SYSTEM_DISK_DRIVE_LETTER_CONFLICT: WIN32_ERROR = WIN32_ERROR(5903u32);
pub const ERROR_CLUSTER_OLD_VERSION: WIN32_ERROR = WIN32_ERROR(5904u32);
pub const ERROR_CLUSTER_MISMATCHED_COMPUTER_ACCT_NAME: WIN32_ERROR = WIN32_ERROR(5905u32);
pub const ERROR_CLUSTER_NO_NET_ADAPTERS: WIN32_ERROR = WIN32_ERROR(5906u32);
pub const ERROR_CLUSTER_POISONED: WIN32_ERROR = WIN32_ERROR(5907u32);
pub const ERROR_CLUSTER_GROUP_MOVING: WIN32_ERROR = WIN32_ERROR(5908u32);
pub const ERROR_CLUSTER_RESOURCE_TYPE_BUSY: WIN32_ERROR = WIN32_ERROR(5909u32);
pub const ERROR_RESOURCE_CALL_TIMED_OUT: WIN32_ERROR = WIN32_ERROR(5910u32);
pub const ERROR_INVALID_CLUSTER_IPV6_ADDRESS: WIN32_ERROR = WIN32_ERROR(5911u32);
pub const ERROR_CLUSTER_INTERNAL_INVALID_FUNCTION: WIN32_ERROR = WIN32_ERROR(5912u32);
pub const ERROR_CLUSTER_PARAMETER_OUT_OF_BOUNDS: WIN32_ERROR = WIN32_ERROR(5913u32);
pub const ERROR_CLUSTER_PARTIAL_SEND: WIN32_ERROR = WIN32_ERROR(5914u32);
pub const ERROR_CLUSTER_REGISTRY_INVALID_FUNCTION: WIN32_ERROR = WIN32_ERROR(5915u32);
pub const ERROR_CLUSTER_INVALID_STRING_TERMINATION: WIN32_ERROR = WIN32_ERROR(5916u32);
pub const ERROR_CLUSTER_INVALID_STRING_FORMAT: WIN32_ERROR = WIN32_ERROR(5917u32);
pub const ERROR_CLUSTER_DATABASE_TRANSACTION_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(5918u32);
pub const ERROR_CLUSTER_DATABASE_TRANSACTION_NOT_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(5919u32);
pub const ERROR_CLUSTER_NULL_DATA: WIN32_ERROR = WIN32_ERROR(5920u32);
pub const ERROR_CLUSTER_PARTIAL_READ: WIN32_ERROR = WIN32_ERROR(5921u32);
pub const ERROR_CLUSTER_PARTIAL_WRITE: WIN32_ERROR = WIN32_ERROR(5922u32);
pub const ERROR_CLUSTER_CANT_DESERIALIZE_DATA: WIN32_ERROR = WIN32_ERROR(5923u32);
pub const ERROR_DEPENDENT_RESOURCE_PROPERTY_CONFLICT: WIN32_ERROR = WIN32_ERROR(5924u32);
pub const ERROR_CLUSTER_NO_QUORUM: WIN32_ERROR = WIN32_ERROR(5925u32);
pub const ERROR_CLUSTER_INVALID_IPV6_NETWORK: WIN32_ERROR = WIN32_ERROR(5926u32);
pub const ERROR_CLUSTER_INVALID_IPV6_TUNNEL_NETWORK: WIN32_ERROR = WIN32_ERROR(5927u32);
pub const ERROR_QUORUM_NOT_ALLOWED_IN_THIS_GROUP: WIN32_ERROR = WIN32_ERROR(5928u32);
pub const ERROR_DEPENDENCY_TREE_TOO_COMPLEX: WIN32_ERROR = WIN32_ERROR(5929u32);
pub const ERROR_EXCEPTION_IN_RESOURCE_CALL: WIN32_ERROR = WIN32_ERROR(5930u32);
pub const ERROR_CLUSTER_RHS_FAILED_INITIALIZATION: WIN32_ERROR = WIN32_ERROR(5931u32);
pub const ERROR_CLUSTER_NOT_INSTALLED: WIN32_ERROR = WIN32_ERROR(5932u32);
pub const ERROR_CLUSTER_RESOURCES_MUST_BE_ONLINE_ON_THE_SAME_NODE: WIN32_ERROR = WIN32_ERROR(5933u32);
pub const ERROR_CLUSTER_MAX_NODES_IN_CLUSTER: WIN32_ERROR = WIN32_ERROR(5934u32);
pub const ERROR_CLUSTER_TOO_MANY_NODES: WIN32_ERROR = WIN32_ERROR(5935u32);
pub const ERROR_CLUSTER_OBJECT_ALREADY_USED: WIN32_ERROR = WIN32_ERROR(5936u32);
pub const ERROR_NONCORE_GROUPS_FOUND: WIN32_ERROR = WIN32_ERROR(5937u32);
pub const ERROR_FILE_SHARE_RESOURCE_CONFLICT: WIN32_ERROR = WIN32_ERROR(5938u32);
pub const ERROR_CLUSTER_EVICT_INVALID_REQUEST: WIN32_ERROR = WIN32_ERROR(5939u32);
pub const ERROR_CLUSTER_SINGLETON_RESOURCE: WIN32_ERROR = WIN32_ERROR(5940u32);
pub const ERROR_CLUSTER_GROUP_SINGLETON_RESOURCE: WIN32_ERROR = WIN32_ERROR(5941u32);
pub const ERROR_CLUSTER_RESOURCE_PROVIDER_FAILED: WIN32_ERROR = WIN32_ERROR(5942u32);
pub const ERROR_CLUSTER_RESOURCE_CONFIGURATION_ERROR: WIN32_ERROR = WIN32_ERROR(5943u32);
pub const ERROR_CLUSTER_GROUP_BUSY: WIN32_ERROR = WIN32_ERROR(5944u32);
pub const ERROR_CLUSTER_NOT_SHARED_VOLUME: WIN32_ERROR = WIN32_ERROR(5945u32);
pub const ERROR_CLUSTER_INVALID_SECURITY_DESCRIPTOR: WIN32_ERROR = WIN32_ERROR(5946u32);
pub const ERROR_CLUSTER_SHARED_VOLUMES_IN_USE: WIN32_ERROR = WIN32_ERROR(5947u32);
pub const ERROR_CLUSTER_USE_SHARED_VOLUMES_API: WIN32_ERROR = WIN32_ERROR(5948u32);
pub const ERROR_CLUSTER_BACKUP_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(5949u32);
pub const ERROR_NON_CSV_PATH: WIN32_ERROR = WIN32_ERROR(5950u32);
pub const ERROR_CSV_VOLUME_NOT_LOCAL: WIN32_ERROR = WIN32_ERROR(5951u32);
pub const ERROR_CLUSTER_WATCHDOG_TERMINATING: WIN32_ERROR = WIN32_ERROR(5952u32);
pub const ERROR_CLUSTER_RESOURCE_VETOED_MOVE_INCOMPATIBLE_NODES: WIN32_ERROR = WIN32_ERROR(5953u32);
pub const ERROR_CLUSTER_INVALID_NODE_WEIGHT: WIN32_ERROR = WIN32_ERROR(5954u32);
pub const ERROR_CLUSTER_RESOURCE_VETOED_CALL: WIN32_ERROR = WIN32_ERROR(5955u32);
pub const ERROR_RESMON_SYSTEM_RESOURCES_LACKING: WIN32_ERROR = WIN32_ERROR(5956u32);
pub const ERROR_CLUSTER_RESOURCE_VETOED_MOVE_NOT_ENOUGH_RESOURCES_ON_DESTINATION: WIN32_ERROR = WIN32_ERROR(5957u32);
pub const ERROR_CLUSTER_RESOURCE_VETOED_MOVE_NOT_ENOUGH_RESOURCES_ON_SOURCE: WIN32_ERROR = WIN32_ERROR(5958u32);
pub const ERROR_CLUSTER_GROUP_QUEUED: WIN32_ERROR = WIN32_ERROR(5959u32);
pub const ERROR_CLUSTER_RESOURCE_LOCKED_STATUS: WIN32_ERROR = WIN32_ERROR(5960u32);
pub const ERROR_CLUSTER_SHARED_VOLUME_FAILOVER_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(5961u32);
pub const ERROR_CLUSTER_NODE_DRAIN_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(5962u32);
pub const ERROR_CLUSTER_DISK_NOT_CONNECTED: WIN32_ERROR = WIN32_ERROR(5963u32);
pub const ERROR_DISK_NOT_CSV_CAPABLE: WIN32_ERROR = WIN32_ERROR(5964u32);
pub const ERROR_RESOURCE_NOT_IN_AVAILABLE_STORAGE: WIN32_ERROR = WIN32_ERROR(5965u32);
pub const ERROR_CLUSTER_SHARED_VOLUME_REDIRECTED: WIN32_ERROR = WIN32_ERROR(5966u32);
pub const ERROR_CLUSTER_SHARED_VOLUME_NOT_REDIRECTED: WIN32_ERROR = WIN32_ERROR(5967u32);
pub const ERROR_CLUSTER_CANNOT_RETURN_PROPERTIES: WIN32_ERROR = WIN32_ERROR(5968u32);
pub const ERROR_CLUSTER_RESOURCE_CONTAINS_UNSUPPORTED_DIFF_AREA_FOR_SHARED_VOLUMES: WIN32_ERROR = WIN32_ERROR(5969u32);
pub const ERROR_CLUSTER_RESOURCE_IS_IN_MAINTENANCE_MODE: WIN32_ERROR = WIN32_ERROR(5970u32);
pub const ERROR_CLUSTER_AFFINITY_CONFLICT: WIN32_ERROR = WIN32_ERROR(5971u32);
pub const ERROR_CLUSTER_RESOURCE_IS_REPLICA_VIRTUAL_MACHINE: WIN32_ERROR = WIN32_ERROR(5972u32);
pub const ERROR_CLUSTER_UPGRADE_INCOMPATIBLE_VERSIONS: WIN32_ERROR = WIN32_ERROR(5973u32);
pub const ERROR_CLUSTER_UPGRADE_FIX_QUORUM_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(5974u32);
pub const ERROR_CLUSTER_UPGRADE_RESTART_REQUIRED: WIN32_ERROR = WIN32_ERROR(5975u32);
pub const ERROR_CLUSTER_UPGRADE_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(5976u32);
pub const ERROR_CLUSTER_UPGRADE_INCOMPLETE: WIN32_ERROR = WIN32_ERROR(5977u32);
pub const ERROR_CLUSTER_NODE_IN_GRACE_PERIOD: WIN32_ERROR = WIN32_ERROR(5978u32);
pub const ERROR_CLUSTER_CSV_IO_PAUSE_TIMEOUT: WIN32_ERROR = WIN32_ERROR(5979u32);
pub const ERROR_NODE_NOT_ACTIVE_CLUSTER_MEMBER: WIN32_ERROR = WIN32_ERROR(5980u32);
pub const ERROR_CLUSTER_RESOURCE_NOT_MONITORED: WIN32_ERROR = WIN32_ERROR(5981u32);
pub const ERROR_CLUSTER_RESOURCE_DOES_NOT_SUPPORT_UNMONITORED: WIN32_ERROR = WIN32_ERROR(5982u32);
pub const ERROR_CLUSTER_RESOURCE_IS_REPLICATED: WIN32_ERROR = WIN32_ERROR(5983u32);
pub const ERROR_CLUSTER_NODE_ISOLATED: WIN32_ERROR = WIN32_ERROR(5984u32);
pub const ERROR_CLUSTER_NODE_QUARANTINED: WIN32_ERROR = WIN32_ERROR(5985u32);
pub const ERROR_CLUSTER_DATABASE_UPDATE_CONDITION_FAILED: WIN32_ERROR = WIN32_ERROR(5986u32);
pub const ERROR_CLUSTER_SPACE_DEGRADED: WIN32_ERROR = WIN32_ERROR(5987u32);
pub const ERROR_CLUSTER_TOKEN_DELEGATION_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(5988u32);
pub const ERROR_CLUSTER_CSV_INVALID_HANDLE: WIN32_ERROR = WIN32_ERROR(5989u32);
pub const ERROR_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR: WIN32_ERROR = WIN32_ERROR(5990u32);
pub const ERROR_GROUPSET_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(5991u32);
pub const ERROR_GROUPSET_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5992u32);
pub const ERROR_GROUPSET_CANT_PROVIDE: WIN32_ERROR = WIN32_ERROR(5993u32);
pub const ERROR_CLUSTER_FAULT_DOMAIN_PARENT_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(5994u32);
pub const ERROR_CLUSTER_FAULT_DOMAIN_INVALID_HIERARCHY: WIN32_ERROR = WIN32_ERROR(5995u32);
pub const ERROR_CLUSTER_FAULT_DOMAIN_FAILED_S2D_VALIDATION: WIN32_ERROR = WIN32_ERROR(5996u32);
pub const ERROR_CLUSTER_FAULT_DOMAIN_S2D_CONNECTIVITY_LOSS: WIN32_ERROR = WIN32_ERROR(5997u32);
pub const ERROR_CLUSTER_INVALID_INFRASTRUCTURE_FILESERVER_NAME: WIN32_ERROR = WIN32_ERROR(5998u32);
pub const ERROR_CLUSTERSET_MANAGEMENT_CLUSTER_UNREACHABLE: WIN32_ERROR = WIN32_ERROR(5999u32);
pub const ERROR_ENCRYPTION_FAILED: WIN32_ERROR = WIN32_ERROR(6000u32);
pub const ERROR_DECRYPTION_FAILED: WIN32_ERROR = WIN32_ERROR(6001u32);
pub const ERROR_FILE_ENCRYPTED: WIN32_ERROR = WIN32_ERROR(6002u32);
pub const ERROR_NO_RECOVERY_POLICY: WIN32_ERROR = WIN32_ERROR(6003u32);
pub const ERROR_NO_EFS: WIN32_ERROR = WIN32_ERROR(6004u32);
pub const ERROR_WRONG_EFS: WIN32_ERROR = WIN32_ERROR(6005u32);
pub const ERROR_NO_USER_KEYS: WIN32_ERROR = WIN32_ERROR(6006u32);
pub const ERROR_FILE_NOT_ENCRYPTED: WIN32_ERROR = WIN32_ERROR(6007u32);
pub const ERROR_NOT_EXPORT_FORMAT: WIN32_ERROR = WIN32_ERROR(6008u32);
pub const ERROR_FILE_READ_ONLY: WIN32_ERROR = WIN32_ERROR(6009u32);
pub const ERROR_DIR_EFS_DISALLOWED: WIN32_ERROR = WIN32_ERROR(6010u32);
pub const ERROR_EFS_SERVER_NOT_TRUSTED: WIN32_ERROR = WIN32_ERROR(6011u32);
pub const ERROR_BAD_RECOVERY_POLICY: WIN32_ERROR = WIN32_ERROR(6012u32);
pub const ERROR_EFS_ALG_BLOB_TOO_BIG: WIN32_ERROR = WIN32_ERROR(6013u32);
pub const ERROR_VOLUME_NOT_SUPPORT_EFS: WIN32_ERROR = WIN32_ERROR(6014u32);
pub const ERROR_EFS_DISABLED: WIN32_ERROR = WIN32_ERROR(6015u32);
pub const ERROR_EFS_VERSION_NOT_SUPPORT: WIN32_ERROR = WIN32_ERROR(6016u32);
pub const ERROR_CS_ENCRYPTION_INVALID_SERVER_RESPONSE: WIN32_ERROR = WIN32_ERROR(6017u32);
pub const ERROR_CS_ENCRYPTION_UNSUPPORTED_SERVER: WIN32_ERROR = WIN32_ERROR(6018u32);
pub const ERROR_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE: WIN32_ERROR = WIN32_ERROR(6019u32);
pub const ERROR_CS_ENCRYPTION_NEW_ENCRYPTED_FILE: WIN32_ERROR = WIN32_ERROR(6020u32);
pub const ERROR_CS_ENCRYPTION_FILE_NOT_CSE: WIN32_ERROR = WIN32_ERROR(6021u32);
pub const ERROR_ENCRYPTION_POLICY_DENIES_OPERATION: WIN32_ERROR = WIN32_ERROR(6022u32);
pub const ERROR_WIP_ENCRYPTION_FAILED: WIN32_ERROR = WIN32_ERROR(6023u32);
pub const ERROR_NO_BROWSER_SERVERS_FOUND: WIN32_ERROR = WIN32_ERROR(6118u32);
pub const ERROR_CLUSTER_OBJECT_IS_CLUSTER_SET_VM: WIN32_ERROR = WIN32_ERROR(6250u32);
pub const ERROR_LOG_SECTOR_INVALID: WIN32_ERROR = WIN32_ERROR(6600u32);
pub const ERROR_LOG_SECTOR_PARITY_INVALID: WIN32_ERROR = WIN32_ERROR(6601u32);
pub const ERROR_LOG_SECTOR_REMAPPED: WIN32_ERROR = WIN32_ERROR(6602u32);
pub const ERROR_LOG_BLOCK_INCOMPLETE: WIN32_ERROR = WIN32_ERROR(6603u32);
pub const ERROR_LOG_INVALID_RANGE: WIN32_ERROR = WIN32_ERROR(6604u32);
pub const ERROR_LOG_BLOCKS_EXHAUSTED: WIN32_ERROR = WIN32_ERROR(6605u32);
pub const ERROR_LOG_READ_CONTEXT_INVALID: WIN32_ERROR = WIN32_ERROR(6606u32);
pub const ERROR_LOG_RESTART_INVALID: WIN32_ERROR = WIN32_ERROR(6607u32);
pub const ERROR_LOG_BLOCK_VERSION: WIN32_ERROR = WIN32_ERROR(6608u32);
pub const ERROR_LOG_BLOCK_INVALID: WIN32_ERROR = WIN32_ERROR(6609u32);
pub const ERROR_LOG_READ_MODE_INVALID: WIN32_ERROR = WIN32_ERROR(6610u32);
pub const ERROR_LOG_NO_RESTART: WIN32_ERROR = WIN32_ERROR(6611u32);
pub const ERROR_LOG_METADATA_CORRUPT: WIN32_ERROR = WIN32_ERROR(6612u32);
pub const ERROR_LOG_METADATA_INVALID: WIN32_ERROR = WIN32_ERROR(6613u32);
pub const ERROR_LOG_METADATA_INCONSISTENT: WIN32_ERROR = WIN32_ERROR(6614u32);
pub const ERROR_LOG_RESERVATION_INVALID: WIN32_ERROR = WIN32_ERROR(6615u32);
pub const ERROR_LOG_CANT_DELETE: WIN32_ERROR = WIN32_ERROR(6616u32);
pub const ERROR_LOG_CONTAINER_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(6617u32);
pub const ERROR_LOG_START_OF_LOG: WIN32_ERROR = WIN32_ERROR(6618u32);
pub const ERROR_LOG_POLICY_ALREADY_INSTALLED: WIN32_ERROR = WIN32_ERROR(6619u32);
pub const ERROR_LOG_POLICY_NOT_INSTALLED: WIN32_ERROR = WIN32_ERROR(6620u32);
pub const ERROR_LOG_POLICY_INVALID: WIN32_ERROR = WIN32_ERROR(6621u32);
pub const ERROR_LOG_POLICY_CONFLICT: WIN32_ERROR = WIN32_ERROR(6622u32);
pub const ERROR_LOG_PINNED_ARCHIVE_TAIL: WIN32_ERROR = WIN32_ERROR(6623u32);
pub const ERROR_LOG_RECORD_NONEXISTENT: WIN32_ERROR = WIN32_ERROR(6624u32);
pub const ERROR_LOG_RECORDS_RESERVED_INVALID: WIN32_ERROR = WIN32_ERROR(6625u32);
pub const ERROR_LOG_SPACE_RESERVED_INVALID: WIN32_ERROR = WIN32_ERROR(6626u32);
pub const ERROR_LOG_TAIL_INVALID: WIN32_ERROR = WIN32_ERROR(6627u32);
pub const ERROR_LOG_FULL: WIN32_ERROR = WIN32_ERROR(6628u32);
pub const ERROR_COULD_NOT_RESIZE_LOG: WIN32_ERROR = WIN32_ERROR(6629u32);
pub const ERROR_LOG_MULTIPLEXED: WIN32_ERROR = WIN32_ERROR(6630u32);
pub const ERROR_LOG_DEDICATED: WIN32_ERROR = WIN32_ERROR(6631u32);
pub const ERROR_LOG_ARCHIVE_NOT_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(6632u32);
pub const ERROR_LOG_ARCHIVE_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(6633u32);
pub const ERROR_LOG_EPHEMERAL: WIN32_ERROR = WIN32_ERROR(6634u32);
pub const ERROR_LOG_NOT_ENOUGH_CONTAINERS: WIN32_ERROR = WIN32_ERROR(6635u32);
pub const ERROR_LOG_CLIENT_ALREADY_REGISTERED: WIN32_ERROR = WIN32_ERROR(6636u32);
pub const ERROR_LOG_CLIENT_NOT_REGISTERED: WIN32_ERROR = WIN32_ERROR(6637u32);
pub const ERROR_LOG_FULL_HANDLER_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(6638u32);
pub const ERROR_LOG_CONTAINER_READ_FAILED: WIN32_ERROR = WIN32_ERROR(6639u32);
pub const ERROR_LOG_CONTAINER_WRITE_FAILED: WIN32_ERROR = WIN32_ERROR(6640u32);
pub const ERROR_LOG_CONTAINER_OPEN_FAILED: WIN32_ERROR = WIN32_ERROR(6641u32);
pub const ERROR_LOG_CONTAINER_STATE_INVALID: WIN32_ERROR = WIN32_ERROR(6642u32);
pub const ERROR_LOG_STATE_INVALID: WIN32_ERROR = WIN32_ERROR(6643u32);
pub const ERROR_LOG_PINNED: WIN32_ERROR = WIN32_ERROR(6644u32);
pub const ERROR_LOG_METADATA_FLUSH_FAILED: WIN32_ERROR = WIN32_ERROR(6645u32);
pub const ERROR_LOG_INCONSISTENT_SECURITY: WIN32_ERROR = WIN32_ERROR(6646u32);
pub const ERROR_LOG_APPENDED_FLUSH_FAILED: WIN32_ERROR = WIN32_ERROR(6647u32);
pub const ERROR_LOG_PINNED_RESERVATION: WIN32_ERROR = WIN32_ERROR(6648u32);
pub const ERROR_INVALID_TRANSACTION: WIN32_ERROR = WIN32_ERROR(6700u32);
pub const ERROR_TRANSACTION_NOT_ACTIVE: WIN32_ERROR = WIN32_ERROR(6701u32);
pub const ERROR_TRANSACTION_REQUEST_NOT_VALID: WIN32_ERROR = WIN32_ERROR(6702u32);
pub const ERROR_TRANSACTION_NOT_REQUESTED: WIN32_ERROR = WIN32_ERROR(6703u32);
pub const ERROR_TRANSACTION_ALREADY_ABORTED: WIN32_ERROR = WIN32_ERROR(6704u32);
pub const ERROR_TRANSACTION_ALREADY_COMMITTED: WIN32_ERROR = WIN32_ERROR(6705u32);
pub const ERROR_TM_INITIALIZATION_FAILED: WIN32_ERROR = WIN32_ERROR(6706u32);
pub const ERROR_RESOURCEMANAGER_READ_ONLY: WIN32_ERROR = WIN32_ERROR(6707u32);
pub const ERROR_TRANSACTION_NOT_JOINED: WIN32_ERROR = WIN32_ERROR(6708u32);
pub const ERROR_TRANSACTION_SUPERIOR_EXISTS: WIN32_ERROR = WIN32_ERROR(6709u32);
pub const ERROR_CRM_PROTOCOL_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(6710u32);
pub const ERROR_TRANSACTION_PROPAGATION_FAILED: WIN32_ERROR = WIN32_ERROR(6711u32);
pub const ERROR_CRM_PROTOCOL_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(6712u32);
pub const ERROR_TRANSACTION_INVALID_MARSHALL_BUFFER: WIN32_ERROR = WIN32_ERROR(6713u32);
pub const ERROR_CURRENT_TRANSACTION_NOT_VALID: WIN32_ERROR = WIN32_ERROR(6714u32);
pub const ERROR_TRANSACTION_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(6715u32);
pub const ERROR_RESOURCEMANAGER_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(6716u32);
pub const ERROR_ENLISTMENT_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(6717u32);
pub const ERROR_TRANSACTIONMANAGER_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(6718u32);
pub const ERROR_TRANSACTIONMANAGER_NOT_ONLINE: WIN32_ERROR = WIN32_ERROR(6719u32);
pub const ERROR_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION: WIN32_ERROR = WIN32_ERROR(6720u32);
pub const ERROR_TRANSACTION_NOT_ROOT: WIN32_ERROR = WIN32_ERROR(6721u32);
pub const ERROR_TRANSACTION_OBJECT_EXPIRED: WIN32_ERROR = WIN32_ERROR(6722u32);
pub const ERROR_TRANSACTION_RESPONSE_NOT_ENLISTED: WIN32_ERROR = WIN32_ERROR(6723u32);
pub const ERROR_TRANSACTION_RECORD_TOO_LONG: WIN32_ERROR = WIN32_ERROR(6724u32);
pub const ERROR_IMPLICIT_TRANSACTION_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(6725u32);
pub const ERROR_TRANSACTION_INTEGRITY_VIOLATED: WIN32_ERROR = WIN32_ERROR(6726u32);
pub const ERROR_TRANSACTIONMANAGER_IDENTITY_MISMATCH: WIN32_ERROR = WIN32_ERROR(6727u32);
pub const ERROR_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOT: WIN32_ERROR = WIN32_ERROR(6728u32);
pub const ERROR_TRANSACTION_MUST_WRITETHROUGH: WIN32_ERROR = WIN32_ERROR(6729u32);
pub const ERROR_TRANSACTION_NO_SUPERIOR: WIN32_ERROR = WIN32_ERROR(6730u32);
pub const ERROR_HEURISTIC_DAMAGE_POSSIBLE: WIN32_ERROR = WIN32_ERROR(6731u32);
pub const ERROR_TRANSACTIONAL_CONFLICT: WIN32_ERROR = WIN32_ERROR(6800u32);
pub const ERROR_RM_NOT_ACTIVE: WIN32_ERROR = WIN32_ERROR(6801u32);
pub const ERROR_RM_METADATA_CORRUPT: WIN32_ERROR = WIN32_ERROR(6802u32);
pub const ERROR_DIRECTORY_NOT_RM: WIN32_ERROR = WIN32_ERROR(6803u32);
pub const ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE: WIN32_ERROR = WIN32_ERROR(6805u32);
pub const ERROR_LOG_RESIZE_INVALID_SIZE: WIN32_ERROR = WIN32_ERROR(6806u32);
pub const ERROR_OBJECT_NO_LONGER_EXISTS: WIN32_ERROR = WIN32_ERROR(6807u32);
pub const ERROR_STREAM_MINIVERSION_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(6808u32);
pub const ERROR_STREAM_MINIVERSION_NOT_VALID: WIN32_ERROR = WIN32_ERROR(6809u32);
pub const ERROR_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION: WIN32_ERROR = WIN32_ERROR(6810u32);
pub const ERROR_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT: WIN32_ERROR = WIN32_ERROR(6811u32);
pub const ERROR_CANT_CREATE_MORE_STREAM_MINIVERSIONS: WIN32_ERROR = WIN32_ERROR(6812u32);
pub const ERROR_REMOTE_FILE_VERSION_MISMATCH: WIN32_ERROR = WIN32_ERROR(6814u32);
pub const ERROR_HANDLE_NO_LONGER_VALID: WIN32_ERROR = WIN32_ERROR(6815u32);
pub const ERROR_NO_TXF_METADATA: WIN32_ERROR = WIN32_ERROR(6816u32);
pub const ERROR_LOG_CORRUPTION_DETECTED: WIN32_ERROR = WIN32_ERROR(6817u32);
pub const ERROR_CANT_RECOVER_WITH_HANDLE_OPEN: WIN32_ERROR = WIN32_ERROR(6818u32);
pub const ERROR_RM_DISCONNECTED: WIN32_ERROR = WIN32_ERROR(6819u32);
pub const ERROR_ENLISTMENT_NOT_SUPERIOR: WIN32_ERROR = WIN32_ERROR(6820u32);
pub const ERROR_RECOVERY_NOT_NEEDED: WIN32_ERROR = WIN32_ERROR(6821u32);
pub const ERROR_RM_ALREADY_STARTED: WIN32_ERROR = WIN32_ERROR(6822u32);
pub const ERROR_FILE_IDENTITY_NOT_PERSISTENT: WIN32_ERROR = WIN32_ERROR(6823u32);
pub const ERROR_CANT_BREAK_TRANSACTIONAL_DEPENDENCY: WIN32_ERROR = WIN32_ERROR(6824u32);
pub const ERROR_CANT_CROSS_RM_BOUNDARY: WIN32_ERROR = WIN32_ERROR(6825u32);
pub const ERROR_TXF_DIR_NOT_EMPTY: WIN32_ERROR = WIN32_ERROR(6826u32);
pub const ERROR_INDOUBT_TRANSACTIONS_EXIST: WIN32_ERROR = WIN32_ERROR(6827u32);
pub const ERROR_TM_VOLATILE: WIN32_ERROR = WIN32_ERROR(6828u32);
pub const ERROR_ROLLBACK_TIMER_EXPIRED: WIN32_ERROR = WIN32_ERROR(6829u32);
pub const ERROR_TXF_ATTRIBUTE_CORRUPT: WIN32_ERROR = WIN32_ERROR(6830u32);
pub const ERROR_EFS_NOT_ALLOWED_IN_TRANSACTION: WIN32_ERROR = WIN32_ERROR(6831u32);
pub const ERROR_TRANSACTIONAL_OPEN_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(6832u32);
pub const ERROR_LOG_GROWTH_FAILED: WIN32_ERROR = WIN32_ERROR(6833u32);
pub const ERROR_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE: WIN32_ERROR = WIN32_ERROR(6834u32);
pub const ERROR_TXF_METADATA_ALREADY_PRESENT: WIN32_ERROR = WIN32_ERROR(6835u32);
pub const ERROR_TRANSACTION_SCOPE_CALLBACKS_NOT_SET: WIN32_ERROR = WIN32_ERROR(6836u32);
pub const ERROR_TRANSACTION_REQUIRED_PROMOTION: WIN32_ERROR = WIN32_ERROR(6837u32);
pub const ERROR_CANNOT_EXECUTE_FILE_IN_TRANSACTION: WIN32_ERROR = WIN32_ERROR(6838u32);
pub const ERROR_TRANSACTIONS_NOT_FROZEN: WIN32_ERROR = WIN32_ERROR(6839u32);
pub const ERROR_TRANSACTION_FREEZE_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(6840u32);
pub const ERROR_NOT_SNAPSHOT_VOLUME: WIN32_ERROR = WIN32_ERROR(6841u32);
pub const ERROR_NO_SAVEPOINT_WITH_OPEN_FILES: WIN32_ERROR = WIN32_ERROR(6842u32);
pub const ERROR_DATA_LOST_REPAIR: WIN32_ERROR = WIN32_ERROR(6843u32);
pub const ERROR_SPARSE_NOT_ALLOWED_IN_TRANSACTION: WIN32_ERROR = WIN32_ERROR(6844u32);
pub const ERROR_TM_IDENTITY_MISMATCH: WIN32_ERROR = WIN32_ERROR(6845u32);
pub const ERROR_FLOATED_SECTION: WIN32_ERROR = WIN32_ERROR(6846u32);
pub const ERROR_CANNOT_ACCEPT_TRANSACTED_WORK: WIN32_ERROR = WIN32_ERROR(6847u32);
pub const ERROR_CANNOT_ABORT_TRANSACTIONS: WIN32_ERROR = WIN32_ERROR(6848u32);
pub const ERROR_BAD_CLUSTERS: WIN32_ERROR = WIN32_ERROR(6849u32);
pub const ERROR_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION: WIN32_ERROR = WIN32_ERROR(6850u32);
pub const ERROR_VOLUME_DIRTY: WIN32_ERROR = WIN32_ERROR(6851u32);
pub const ERROR_NO_LINK_TRACKING_IN_TRANSACTION: WIN32_ERROR = WIN32_ERROR(6852u32);
pub const ERROR_OPERATION_NOT_SUPPORTED_IN_TRANSACTION: WIN32_ERROR = WIN32_ERROR(6853u32);
pub const ERROR_EXPIRED_HANDLE: WIN32_ERROR = WIN32_ERROR(6854u32);
pub const ERROR_TRANSACTION_NOT_ENLISTED: WIN32_ERROR = WIN32_ERROR(6855u32);
pub const ERROR_CTX_WINSTATION_NAME_INVALID: WIN32_ERROR = WIN32_ERROR(7001u32);
pub const ERROR_CTX_INVALID_PD: WIN32_ERROR = WIN32_ERROR(7002u32);
pub const ERROR_CTX_PD_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(7003u32);
pub const ERROR_CTX_WD_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(7004u32);
pub const ERROR_CTX_CANNOT_MAKE_EVENTLOG_ENTRY: WIN32_ERROR = WIN32_ERROR(7005u32);
pub const ERROR_CTX_SERVICE_NAME_COLLISION: WIN32_ERROR = WIN32_ERROR(7006u32);
pub const ERROR_CTX_CLOSE_PENDING: WIN32_ERROR = WIN32_ERROR(7007u32);
pub const ERROR_CTX_NO_OUTBUF: WIN32_ERROR = WIN32_ERROR(7008u32);
pub const ERROR_CTX_MODEM_INF_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(7009u32);
pub const ERROR_CTX_INVALID_MODEMNAME: WIN32_ERROR = WIN32_ERROR(7010u32);
pub const ERROR_CTX_MODEM_RESPONSE_ERROR: WIN32_ERROR = WIN32_ERROR(7011u32);
pub const ERROR_CTX_MODEM_RESPONSE_TIMEOUT: WIN32_ERROR = WIN32_ERROR(7012u32);
pub const ERROR_CTX_MODEM_RESPONSE_NO_CARRIER: WIN32_ERROR = WIN32_ERROR(7013u32);
pub const ERROR_CTX_MODEM_RESPONSE_NO_DIALTONE: WIN32_ERROR = WIN32_ERROR(7014u32);
pub const ERROR_CTX_MODEM_RESPONSE_BUSY: WIN32_ERROR = WIN32_ERROR(7015u32);
pub const ERROR_CTX_MODEM_RESPONSE_VOICE: WIN32_ERROR = WIN32_ERROR(7016u32);
pub const ERROR_CTX_TD_ERROR: WIN32_ERROR = WIN32_ERROR(7017u32);
pub const ERROR_CTX_WINSTATION_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(7022u32);
pub const ERROR_CTX_WINSTATION_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(7023u32);
pub const ERROR_CTX_WINSTATION_BUSY: WIN32_ERROR = WIN32_ERROR(7024u32);
pub const ERROR_CTX_BAD_VIDEO_MODE: WIN32_ERROR = WIN32_ERROR(7025u32);
pub const ERROR_CTX_GRAPHICS_INVALID: WIN32_ERROR = WIN32_ERROR(7035u32);
pub const ERROR_CTX_LOGON_DISABLED: WIN32_ERROR = WIN32_ERROR(7037u32);
pub const ERROR_CTX_NOT_CONSOLE: WIN32_ERROR = WIN32_ERROR(7038u32);
pub const ERROR_CTX_CLIENT_QUERY_TIMEOUT: WIN32_ERROR = WIN32_ERROR(7040u32);
pub const ERROR_CTX_CONSOLE_DISCONNECT: WIN32_ERROR = WIN32_ERROR(7041u32);
pub const ERROR_CTX_CONSOLE_CONNECT: WIN32_ERROR = WIN32_ERROR(7042u32);
pub const ERROR_CTX_SHADOW_DENIED: WIN32_ERROR = WIN32_ERROR(7044u32);
pub const ERROR_CTX_WINSTATION_ACCESS_DENIED: WIN32_ERROR = WIN32_ERROR(7045u32);
pub const ERROR_CTX_INVALID_WD: WIN32_ERROR = WIN32_ERROR(7049u32);
pub const ERROR_CTX_SHADOW_INVALID: WIN32_ERROR = WIN32_ERROR(7050u32);
pub const ERROR_CTX_SHADOW_DISABLED: WIN32_ERROR = WIN32_ERROR(7051u32);
pub const ERROR_CTX_CLIENT_LICENSE_IN_USE: WIN32_ERROR = WIN32_ERROR(7052u32);
pub const ERROR_CTX_CLIENT_LICENSE_NOT_SET: WIN32_ERROR = WIN32_ERROR(7053u32);
pub const ERROR_CTX_LICENSE_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(7054u32);
pub const ERROR_CTX_LICENSE_CLIENT_INVALID: WIN32_ERROR = WIN32_ERROR(7055u32);
pub const ERROR_CTX_LICENSE_EXPIRED: WIN32_ERROR = WIN32_ERROR(7056u32);
pub const ERROR_CTX_SHADOW_NOT_RUNNING: WIN32_ERROR = WIN32_ERROR(7057u32);
pub const ERROR_CTX_SHADOW_ENDED_BY_MODE_CHANGE: WIN32_ERROR = WIN32_ERROR(7058u32);
pub const ERROR_ACTIVATION_COUNT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(7059u32);
pub const ERROR_CTX_WINSTATIONS_DISABLED: WIN32_ERROR = WIN32_ERROR(7060u32);
pub const ERROR_CTX_ENCRYPTION_LEVEL_REQUIRED: WIN32_ERROR = WIN32_ERROR(7061u32);
pub const ERROR_CTX_SESSION_IN_USE: WIN32_ERROR = WIN32_ERROR(7062u32);
pub const ERROR_CTX_NO_FORCE_LOGOFF: WIN32_ERROR = WIN32_ERROR(7063u32);
pub const ERROR_CTX_ACCOUNT_RESTRICTION: WIN32_ERROR = WIN32_ERROR(7064u32);
pub const ERROR_RDP_PROTOCOL_ERROR: WIN32_ERROR = WIN32_ERROR(7065u32);
pub const ERROR_CTX_CDM_CONNECT: WIN32_ERROR = WIN32_ERROR(7066u32);
pub const ERROR_CTX_CDM_DISCONNECT: WIN32_ERROR = WIN32_ERROR(7067u32);
pub const ERROR_CTX_SECURITY_LAYER_ERROR: WIN32_ERROR = WIN32_ERROR(7068u32);
pub const ERROR_TS_INCOMPATIBLE_SESSIONS: WIN32_ERROR = WIN32_ERROR(7069u32);
pub const ERROR_TS_VIDEO_SUBSYSTEM_ERROR: WIN32_ERROR = WIN32_ERROR(7070u32);
pub const ERROR_DS_NOT_INSTALLED: WIN32_ERROR = WIN32_ERROR(8200u32);
pub const ERROR_DS_MEMBERSHIP_EVALUATED_LOCALLY: WIN32_ERROR = WIN32_ERROR(8201u32);
pub const ERROR_DS_NO_ATTRIBUTE_OR_VALUE: WIN32_ERROR = WIN32_ERROR(8202u32);
pub const ERROR_DS_INVALID_ATTRIBUTE_SYNTAX: WIN32_ERROR = WIN32_ERROR(8203u32);
pub const ERROR_DS_ATTRIBUTE_TYPE_UNDEFINED: WIN32_ERROR = WIN32_ERROR(8204u32);
pub const ERROR_DS_ATTRIBUTE_OR_VALUE_EXISTS: WIN32_ERROR = WIN32_ERROR(8205u32);
pub const ERROR_DS_BUSY: WIN32_ERROR = WIN32_ERROR(8206u32);
pub const ERROR_DS_UNAVAILABLE: WIN32_ERROR = WIN32_ERROR(8207u32);
pub const ERROR_DS_NO_RIDS_ALLOCATED: WIN32_ERROR = WIN32_ERROR(8208u32);
pub const ERROR_DS_NO_MORE_RIDS: WIN32_ERROR = WIN32_ERROR(8209u32);
pub const ERROR_DS_INCORRECT_ROLE_OWNER: WIN32_ERROR = WIN32_ERROR(8210u32);
pub const ERROR_DS_RIDMGR_INIT_ERROR: WIN32_ERROR = WIN32_ERROR(8211u32);
pub const ERROR_DS_OBJ_CLASS_VIOLATION: WIN32_ERROR = WIN32_ERROR(8212u32);
pub const ERROR_DS_CANT_ON_NON_LEAF: WIN32_ERROR = WIN32_ERROR(8213u32);
pub const ERROR_DS_CANT_ON_RDN: WIN32_ERROR = WIN32_ERROR(8214u32);
pub const ERROR_DS_CANT_MOD_OBJ_CLASS: WIN32_ERROR = WIN32_ERROR(8215u32);
pub const ERROR_DS_CROSS_DOM_MOVE_ERROR: WIN32_ERROR = WIN32_ERROR(8216u32);
pub const ERROR_DS_GC_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(8217u32);
pub const ERROR_SHARED_POLICY: WIN32_ERROR = WIN32_ERROR(8218u32);
pub const ERROR_POLICY_OBJECT_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(8219u32);
pub const ERROR_POLICY_ONLY_IN_DS: WIN32_ERROR = WIN32_ERROR(8220u32);
pub const ERROR_PROMOTION_ACTIVE: WIN32_ERROR = WIN32_ERROR(8221u32);
pub const ERROR_NO_PROMOTION_ACTIVE: WIN32_ERROR = WIN32_ERROR(8222u32);
pub const ERROR_DS_OPERATIONS_ERROR: WIN32_ERROR = WIN32_ERROR(8224u32);
pub const ERROR_DS_PROTOCOL_ERROR: WIN32_ERROR = WIN32_ERROR(8225u32);
pub const ERROR_DS_TIMELIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(8226u32);
pub const ERROR_DS_SIZELIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(8227u32);
pub const ERROR_DS_ADMIN_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(8228u32);
pub const ERROR_DS_COMPARE_FALSE: WIN32_ERROR = WIN32_ERROR(8229u32);
pub const ERROR_DS_COMPARE_TRUE: WIN32_ERROR = WIN32_ERROR(8230u32);
pub const ERROR_DS_AUTH_METHOD_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(8231u32);
pub const ERROR_DS_STRONG_AUTH_REQUIRED: WIN32_ERROR = WIN32_ERROR(8232u32);
pub const ERROR_DS_INAPPROPRIATE_AUTH: WIN32_ERROR = WIN32_ERROR(8233u32);
pub const ERROR_DS_AUTH_UNKNOWN: WIN32_ERROR = WIN32_ERROR(8234u32);
pub const ERROR_DS_REFERRAL: WIN32_ERROR = WIN32_ERROR(8235u32);
pub const ERROR_DS_UNAVAILABLE_CRIT_EXTENSION: WIN32_ERROR = WIN32_ERROR(8236u32);
pub const ERROR_DS_CONFIDENTIALITY_REQUIRED: WIN32_ERROR = WIN32_ERROR(8237u32);
pub const ERROR_DS_INAPPROPRIATE_MATCHING: WIN32_ERROR = WIN32_ERROR(8238u32);
pub const ERROR_DS_CONSTRAINT_VIOLATION: WIN32_ERROR = WIN32_ERROR(8239u32);
pub const ERROR_DS_NO_SUCH_OBJECT: WIN32_ERROR = WIN32_ERROR(8240u32);
pub const ERROR_DS_ALIAS_PROBLEM: WIN32_ERROR = WIN32_ERROR(8241u32);
pub const ERROR_DS_INVALID_DN_SYNTAX: WIN32_ERROR = WIN32_ERROR(8242u32);
pub const ERROR_DS_IS_LEAF: WIN32_ERROR = WIN32_ERROR(8243u32);
pub const ERROR_DS_ALIAS_DEREF_PROBLEM: WIN32_ERROR = WIN32_ERROR(8244u32);
pub const ERROR_DS_UNWILLING_TO_PERFORM: WIN32_ERROR = WIN32_ERROR(8245u32);
pub const ERROR_DS_LOOP_DETECT: WIN32_ERROR = WIN32_ERROR(8246u32);
pub const ERROR_DS_NAMING_VIOLATION: WIN32_ERROR = WIN32_ERROR(8247u32);
pub const ERROR_DS_OBJECT_RESULTS_TOO_LARGE: WIN32_ERROR = WIN32_ERROR(8248u32);
pub const ERROR_DS_AFFECTS_MULTIPLE_DSAS: WIN32_ERROR = WIN32_ERROR(8249u32);
pub const ERROR_DS_SERVER_DOWN: WIN32_ERROR = WIN32_ERROR(8250u32);
pub const ERROR_DS_LOCAL_ERROR: WIN32_ERROR = WIN32_ERROR(8251u32);
pub const ERROR_DS_ENCODING_ERROR: WIN32_ERROR = WIN32_ERROR(8252u32);
pub const ERROR_DS_DECODING_ERROR: WIN32_ERROR = WIN32_ERROR(8253u32);
pub const ERROR_DS_FILTER_UNKNOWN: WIN32_ERROR = WIN32_ERROR(8254u32);
pub const ERROR_DS_PARAM_ERROR: WIN32_ERROR = WIN32_ERROR(8255u32);
pub const ERROR_DS_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(8256u32);
pub const ERROR_DS_NO_RESULTS_RETURNED: WIN32_ERROR = WIN32_ERROR(8257u32);
pub const ERROR_DS_CONTROL_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(8258u32);
pub const ERROR_DS_CLIENT_LOOP: WIN32_ERROR = WIN32_ERROR(8259u32);
pub const ERROR_DS_REFERRAL_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(8260u32);
pub const ERROR_DS_SORT_CONTROL_MISSING: WIN32_ERROR = WIN32_ERROR(8261u32);
pub const ERROR_DS_OFFSET_RANGE_ERROR: WIN32_ERROR = WIN32_ERROR(8262u32);
pub const ERROR_DS_RIDMGR_DISABLED: WIN32_ERROR = WIN32_ERROR(8263u32);
pub const ERROR_DS_ROOT_MUST_BE_NC: WIN32_ERROR = WIN32_ERROR(8301u32);
pub const ERROR_DS_ADD_REPLICA_INHIBITED: WIN32_ERROR = WIN32_ERROR(8302u32);
pub const ERROR_DS_ATT_NOT_DEF_IN_SCHEMA: WIN32_ERROR = WIN32_ERROR(8303u32);
pub const ERROR_DS_MAX_OBJ_SIZE_EXCEEDED: WIN32_ERROR = WIN32_ERROR(8304u32);
pub const ERROR_DS_OBJ_STRING_NAME_EXISTS: WIN32_ERROR = WIN32_ERROR(8305u32);
pub const ERROR_DS_NO_RDN_DEFINED_IN_SCHEMA: WIN32_ERROR = WIN32_ERROR(8306u32);
pub const ERROR_DS_RDN_DOESNT_MATCH_SCHEMA: WIN32_ERROR = WIN32_ERROR(8307u32);
pub const ERROR_DS_NO_REQUESTED_ATTS_FOUND: WIN32_ERROR = WIN32_ERROR(8308u32);
pub const ERROR_DS_USER_BUFFER_TO_SMALL: WIN32_ERROR = WIN32_ERROR(8309u32);
pub const ERROR_DS_ATT_IS_NOT_ON_OBJ: WIN32_ERROR = WIN32_ERROR(8310u32);
pub const ERROR_DS_ILLEGAL_MOD_OPERATION: WIN32_ERROR = WIN32_ERROR(8311u32);
pub const ERROR_DS_OBJ_TOO_LARGE: WIN32_ERROR = WIN32_ERROR(8312u32);
pub const ERROR_DS_BAD_INSTANCE_TYPE: WIN32_ERROR = WIN32_ERROR(8313u32);
pub const ERROR_DS_MASTERDSA_REQUIRED: WIN32_ERROR = WIN32_ERROR(8314u32);
pub const ERROR_DS_OBJECT_CLASS_REQUIRED: WIN32_ERROR = WIN32_ERROR(8315u32);
pub const ERROR_DS_MISSING_REQUIRED_ATT: WIN32_ERROR = WIN32_ERROR(8316u32);
pub const ERROR_DS_ATT_NOT_DEF_FOR_CLASS: WIN32_ERROR = WIN32_ERROR(8317u32);
pub const ERROR_DS_ATT_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(8318u32);
pub const ERROR_DS_CANT_ADD_ATT_VALUES: WIN32_ERROR = WIN32_ERROR(8320u32);
pub const ERROR_DS_SINGLE_VALUE_CONSTRAINT: WIN32_ERROR = WIN32_ERROR(8321u32);
pub const ERROR_DS_RANGE_CONSTRAINT: WIN32_ERROR = WIN32_ERROR(8322u32);
pub const ERROR_DS_ATT_VAL_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(8323u32);
pub const ERROR_DS_CANT_REM_MISSING_ATT: WIN32_ERROR = WIN32_ERROR(8324u32);
pub const ERROR_DS_CANT_REM_MISSING_ATT_VAL: WIN32_ERROR = WIN32_ERROR(8325u32);
pub const ERROR_DS_ROOT_CANT_BE_SUBREF: WIN32_ERROR = WIN32_ERROR(8326u32);
pub const ERROR_DS_NO_CHAINING: WIN32_ERROR = WIN32_ERROR(8327u32);
pub const ERROR_DS_NO_CHAINED_EVAL: WIN32_ERROR = WIN32_ERROR(8328u32);
pub const ERROR_DS_NO_PARENT_OBJECT: WIN32_ERROR = WIN32_ERROR(8329u32);
pub const ERROR_DS_PARENT_IS_AN_ALIAS: WIN32_ERROR = WIN32_ERROR(8330u32);
pub const ERROR_DS_CANT_MIX_MASTER_AND_REPS: WIN32_ERROR = WIN32_ERROR(8331u32);
pub const ERROR_DS_CHILDREN_EXIST: WIN32_ERROR = WIN32_ERROR(8332u32);
pub const ERROR_DS_OBJ_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(8333u32);
pub const ERROR_DS_ALIASED_OBJ_MISSING: WIN32_ERROR = WIN32_ERROR(8334u32);
pub const ERROR_DS_BAD_NAME_SYNTAX: WIN32_ERROR = WIN32_ERROR(8335u32);
pub const ERROR_DS_ALIAS_POINTS_TO_ALIAS: WIN32_ERROR = WIN32_ERROR(8336u32);
pub const ERROR_DS_CANT_DEREF_ALIAS: WIN32_ERROR = WIN32_ERROR(8337u32);
pub const ERROR_DS_OUT_OF_SCOPE: WIN32_ERROR = WIN32_ERROR(8338u32);
pub const ERROR_DS_OBJECT_BEING_REMOVED: WIN32_ERROR = WIN32_ERROR(8339u32);
pub const ERROR_DS_CANT_DELETE_DSA_OBJ: WIN32_ERROR = WIN32_ERROR(8340u32);
pub const ERROR_DS_GENERIC_ERROR: WIN32_ERROR = WIN32_ERROR(8341u32);
pub const ERROR_DS_DSA_MUST_BE_INT_MASTER: WIN32_ERROR = WIN32_ERROR(8342u32);
pub const ERROR_DS_CLASS_NOT_DSA: WIN32_ERROR = WIN32_ERROR(8343u32);
pub const ERROR_DS_INSUFF_ACCESS_RIGHTS: WIN32_ERROR = WIN32_ERROR(8344u32);
pub const ERROR_DS_ILLEGAL_SUPERIOR: WIN32_ERROR = WIN32_ERROR(8345u32);
pub const ERROR_DS_ATTRIBUTE_OWNED_BY_SAM: WIN32_ERROR = WIN32_ERROR(8346u32);
pub const ERROR_DS_NAME_TOO_MANY_PARTS: WIN32_ERROR = WIN32_ERROR(8347u32);
pub const ERROR_DS_NAME_TOO_LONG: WIN32_ERROR = WIN32_ERROR(8348u32);
pub const ERROR_DS_NAME_VALUE_TOO_LONG: WIN32_ERROR = WIN32_ERROR(8349u32);
pub const ERROR_DS_NAME_UNPARSEABLE: WIN32_ERROR = WIN32_ERROR(8350u32);
pub const ERROR_DS_NAME_TYPE_UNKNOWN: WIN32_ERROR = WIN32_ERROR(8351u32);
pub const ERROR_DS_NOT_AN_OBJECT: WIN32_ERROR = WIN32_ERROR(8352u32);
pub const ERROR_DS_SEC_DESC_TOO_SHORT: WIN32_ERROR = WIN32_ERROR(8353u32);
pub const ERROR_DS_SEC_DESC_INVALID: WIN32_ERROR = WIN32_ERROR(8354u32);
pub const ERROR_DS_NO_DELETED_NAME: WIN32_ERROR = WIN32_ERROR(8355u32);
pub const ERROR_DS_SUBREF_MUST_HAVE_PARENT: WIN32_ERROR = WIN32_ERROR(8356u32);
pub const ERROR_DS_NCNAME_MUST_BE_NC: WIN32_ERROR = WIN32_ERROR(8357u32);
pub const ERROR_DS_CANT_ADD_SYSTEM_ONLY: WIN32_ERROR = WIN32_ERROR(8358u32);
pub const ERROR_DS_CLASS_MUST_BE_CONCRETE: WIN32_ERROR = WIN32_ERROR(8359u32);
pub const ERROR_DS_INVALID_DMD: WIN32_ERROR = WIN32_ERROR(8360u32);
pub const ERROR_DS_OBJ_GUID_EXISTS: WIN32_ERROR = WIN32_ERROR(8361u32);
pub const ERROR_DS_NOT_ON_BACKLINK: WIN32_ERROR = WIN32_ERROR(8362u32);
pub const ERROR_DS_NO_CROSSREF_FOR_NC: WIN32_ERROR = WIN32_ERROR(8363u32);
pub const ERROR_DS_SHUTTING_DOWN: WIN32_ERROR = WIN32_ERROR(8364u32);
pub const ERROR_DS_UNKNOWN_OPERATION: WIN32_ERROR = WIN32_ERROR(8365u32);
pub const ERROR_DS_INVALID_ROLE_OWNER: WIN32_ERROR = WIN32_ERROR(8366u32);
pub const ERROR_DS_COULDNT_CONTACT_FSMO: WIN32_ERROR = WIN32_ERROR(8367u32);
pub const ERROR_DS_CROSS_NC_DN_RENAME: WIN32_ERROR = WIN32_ERROR(8368u32);
pub const ERROR_DS_CANT_MOD_SYSTEM_ONLY: WIN32_ERROR = WIN32_ERROR(8369u32);
pub const ERROR_DS_REPLICATOR_ONLY: WIN32_ERROR = WIN32_ERROR(8370u32);
pub const ERROR_DS_OBJ_CLASS_NOT_DEFINED: WIN32_ERROR = WIN32_ERROR(8371u32);
pub const ERROR_DS_OBJ_CLASS_NOT_SUBCLASS: WIN32_ERROR = WIN32_ERROR(8372u32);
pub const ERROR_DS_NAME_REFERENCE_INVALID: WIN32_ERROR = WIN32_ERROR(8373u32);
pub const ERROR_DS_CROSS_REF_EXISTS: WIN32_ERROR = WIN32_ERROR(8374u32);
pub const ERROR_DS_CANT_DEL_MASTER_CROSSREF: WIN32_ERROR = WIN32_ERROR(8375u32);
pub const ERROR_DS_SUBTREE_NOTIFY_NOT_NC_HEAD: WIN32_ERROR = WIN32_ERROR(8376u32);
pub const ERROR_DS_NOTIFY_FILTER_TOO_COMPLEX: WIN32_ERROR = WIN32_ERROR(8377u32);
pub const ERROR_DS_DUP_RDN: WIN32_ERROR = WIN32_ERROR(8378u32);
pub const ERROR_DS_DUP_OID: WIN32_ERROR = WIN32_ERROR(8379u32);
pub const ERROR_DS_DUP_MAPI_ID: WIN32_ERROR = WIN32_ERROR(8380u32);
pub const ERROR_DS_DUP_SCHEMA_ID_GUID: WIN32_ERROR = WIN32_ERROR(8381u32);
pub const ERROR_DS_DUP_LDAP_DISPLAY_NAME: WIN32_ERROR = WIN32_ERROR(8382u32);
pub const ERROR_DS_SEMANTIC_ATT_TEST: WIN32_ERROR = WIN32_ERROR(8383u32);
pub const ERROR_DS_SYNTAX_MISMATCH: WIN32_ERROR = WIN32_ERROR(8384u32);
pub const ERROR_DS_EXISTS_IN_MUST_HAVE: WIN32_ERROR = WIN32_ERROR(8385u32);
pub const ERROR_DS_EXISTS_IN_MAY_HAVE: WIN32_ERROR = WIN32_ERROR(8386u32);
pub const ERROR_DS_NONEXISTENT_MAY_HAVE: WIN32_ERROR = WIN32_ERROR(8387u32);
pub const ERROR_DS_NONEXISTENT_MUST_HAVE: WIN32_ERROR = WIN32_ERROR(8388u32);
pub const ERROR_DS_AUX_CLS_TEST_FAIL: WIN32_ERROR = WIN32_ERROR(8389u32);
pub const ERROR_DS_NONEXISTENT_POSS_SUP: WIN32_ERROR = WIN32_ERROR(8390u32);
pub const ERROR_DS_SUB_CLS_TEST_FAIL: WIN32_ERROR = WIN32_ERROR(8391u32);
pub const ERROR_DS_BAD_RDN_ATT_ID_SYNTAX: WIN32_ERROR = WIN32_ERROR(8392u32);
pub const ERROR_DS_EXISTS_IN_AUX_CLS: WIN32_ERROR = WIN32_ERROR(8393u32);
pub const ERROR_DS_EXISTS_IN_SUB_CLS: WIN32_ERROR = WIN32_ERROR(8394u32);
pub const ERROR_DS_EXISTS_IN_POSS_SUP: WIN32_ERROR = WIN32_ERROR(8395u32);
pub const ERROR_DS_RECALCSCHEMA_FAILED: WIN32_ERROR = WIN32_ERROR(8396u32);
pub const ERROR_DS_TREE_DELETE_NOT_FINISHED: WIN32_ERROR = WIN32_ERROR(8397u32);
pub const ERROR_DS_CANT_DELETE: WIN32_ERROR = WIN32_ERROR(8398u32);
pub const ERROR_DS_ATT_SCHEMA_REQ_ID: WIN32_ERROR = WIN32_ERROR(8399u32);
pub const ERROR_DS_BAD_ATT_SCHEMA_SYNTAX: WIN32_ERROR = WIN32_ERROR(8400u32);
pub const ERROR_DS_CANT_CACHE_ATT: WIN32_ERROR = WIN32_ERROR(8401u32);
pub const ERROR_DS_CANT_CACHE_CLASS: WIN32_ERROR = WIN32_ERROR(8402u32);
pub const ERROR_DS_CANT_REMOVE_ATT_CACHE: WIN32_ERROR = WIN32_ERROR(8403u32);
pub const ERROR_DS_CANT_REMOVE_CLASS_CACHE: WIN32_ERROR = WIN32_ERROR(8404u32);
pub const ERROR_DS_CANT_RETRIEVE_DN: WIN32_ERROR = WIN32_ERROR(8405u32);
pub const ERROR_DS_MISSING_SUPREF: WIN32_ERROR = WIN32_ERROR(8406u32);
pub const ERROR_DS_CANT_RETRIEVE_INSTANCE: WIN32_ERROR = WIN32_ERROR(8407u32);
pub const ERROR_DS_CODE_INCONSISTENCY: WIN32_ERROR = WIN32_ERROR(8408u32);
pub const ERROR_DS_DATABASE_ERROR: WIN32_ERROR = WIN32_ERROR(8409u32);
pub const ERROR_DS_GOVERNSID_MISSING: WIN32_ERROR = WIN32_ERROR(8410u32);
pub const ERROR_DS_MISSING_EXPECTED_ATT: WIN32_ERROR = WIN32_ERROR(8411u32);
pub const ERROR_DS_NCNAME_MISSING_CR_REF: WIN32_ERROR = WIN32_ERROR(8412u32);
pub const ERROR_DS_SECURITY_CHECKING_ERROR: WIN32_ERROR = WIN32_ERROR(8413u32);
pub const ERROR_DS_SCHEMA_NOT_LOADED: WIN32_ERROR = WIN32_ERROR(8414u32);
pub const ERROR_DS_SCHEMA_ALLOC_FAILED: WIN32_ERROR = WIN32_ERROR(8415u32);
pub const ERROR_DS_ATT_SCHEMA_REQ_SYNTAX: WIN32_ERROR = WIN32_ERROR(8416u32);
pub const ERROR_DS_GCVERIFY_ERROR: WIN32_ERROR = WIN32_ERROR(8417u32);
pub const ERROR_DS_DRA_SCHEMA_MISMATCH: WIN32_ERROR = WIN32_ERROR(8418u32);
pub const ERROR_DS_CANT_FIND_DSA_OBJ: WIN32_ERROR = WIN32_ERROR(8419u32);
pub const ERROR_DS_CANT_FIND_EXPECTED_NC: WIN32_ERROR = WIN32_ERROR(8420u32);
pub const ERROR_DS_CANT_FIND_NC_IN_CACHE: WIN32_ERROR = WIN32_ERROR(8421u32);
pub const ERROR_DS_CANT_RETRIEVE_CHILD: WIN32_ERROR = WIN32_ERROR(8422u32);
pub const ERROR_DS_SECURITY_ILLEGAL_MODIFY: WIN32_ERROR = WIN32_ERROR(8423u32);
pub const ERROR_DS_CANT_REPLACE_HIDDEN_REC: WIN32_ERROR = WIN32_ERROR(8424u32);
pub const ERROR_DS_BAD_HIERARCHY_FILE: WIN32_ERROR = WIN32_ERROR(8425u32);
pub const ERROR_DS_BUILD_HIERARCHY_TABLE_FAILED: WIN32_ERROR = WIN32_ERROR(8426u32);
pub const ERROR_DS_CONFIG_PARAM_MISSING: WIN32_ERROR = WIN32_ERROR(8427u32);
pub const ERROR_DS_COUNTING_AB_INDICES_FAILED: WIN32_ERROR = WIN32_ERROR(8428u32);
pub const ERROR_DS_HIERARCHY_TABLE_MALLOC_FAILED: WIN32_ERROR = WIN32_ERROR(8429u32);
pub const ERROR_DS_INTERNAL_FAILURE: WIN32_ERROR = WIN32_ERROR(8430u32);
pub const ERROR_DS_UNKNOWN_ERROR: WIN32_ERROR = WIN32_ERROR(8431u32);
pub const ERROR_DS_ROOT_REQUIRES_CLASS_TOP: WIN32_ERROR = WIN32_ERROR(8432u32);
pub const ERROR_DS_REFUSING_FSMO_ROLES: WIN32_ERROR = WIN32_ERROR(8433u32);
pub const ERROR_DS_MISSING_FSMO_SETTINGS: WIN32_ERROR = WIN32_ERROR(8434u32);
pub const ERROR_DS_UNABLE_TO_SURRENDER_ROLES: WIN32_ERROR = WIN32_ERROR(8435u32);
pub const ERROR_DS_DRA_GENERIC: WIN32_ERROR = WIN32_ERROR(8436u32);
pub const ERROR_DS_DRA_INVALID_PARAMETER: WIN32_ERROR = WIN32_ERROR(8437u32);
pub const ERROR_DS_DRA_BUSY: WIN32_ERROR = WIN32_ERROR(8438u32);
pub const ERROR_DS_DRA_BAD_DN: WIN32_ERROR = WIN32_ERROR(8439u32);
pub const ERROR_DS_DRA_BAD_NC: WIN32_ERROR = WIN32_ERROR(8440u32);
pub const ERROR_DS_DRA_DN_EXISTS: WIN32_ERROR = WIN32_ERROR(8441u32);
pub const ERROR_DS_DRA_INTERNAL_ERROR: WIN32_ERROR = WIN32_ERROR(8442u32);
pub const ERROR_DS_DRA_INCONSISTENT_DIT: WIN32_ERROR = WIN32_ERROR(8443u32);
pub const ERROR_DS_DRA_CONNECTION_FAILED: WIN32_ERROR = WIN32_ERROR(8444u32);
pub const ERROR_DS_DRA_BAD_INSTANCE_TYPE: WIN32_ERROR = WIN32_ERROR(8445u32);
pub const ERROR_DS_DRA_OUT_OF_MEM: WIN32_ERROR = WIN32_ERROR(8446u32);
pub const ERROR_DS_DRA_MAIL_PROBLEM: WIN32_ERROR = WIN32_ERROR(8447u32);
pub const ERROR_DS_DRA_REF_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(8448u32);
pub const ERROR_DS_DRA_REF_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(8449u32);
pub const ERROR_DS_DRA_OBJ_IS_REP_SOURCE: WIN32_ERROR = WIN32_ERROR(8450u32);
pub const ERROR_DS_DRA_DB_ERROR: WIN32_ERROR = WIN32_ERROR(8451u32);
pub const ERROR_DS_DRA_NO_REPLICA: WIN32_ERROR = WIN32_ERROR(8452u32);
pub const ERROR_DS_DRA_ACCESS_DENIED: WIN32_ERROR = WIN32_ERROR(8453u32);
pub const ERROR_DS_DRA_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(8454u32);
pub const ERROR_DS_DRA_RPC_CANCELLED: WIN32_ERROR = WIN32_ERROR(8455u32);
pub const ERROR_DS_DRA_SOURCE_DISABLED: WIN32_ERROR = WIN32_ERROR(8456u32);
pub const ERROR_DS_DRA_SINK_DISABLED: WIN32_ERROR = WIN32_ERROR(8457u32);
pub const ERROR_DS_DRA_NAME_COLLISION: WIN32_ERROR = WIN32_ERROR(8458u32);
pub const ERROR_DS_DRA_SOURCE_REINSTALLED: WIN32_ERROR = WIN32_ERROR(8459u32);
pub const ERROR_DS_DRA_MISSING_PARENT: WIN32_ERROR = WIN32_ERROR(8460u32);
pub const ERROR_DS_DRA_PREEMPTED: WIN32_ERROR = WIN32_ERROR(8461u32);
pub const ERROR_DS_DRA_ABANDON_SYNC: WIN32_ERROR = WIN32_ERROR(8462u32);
pub const ERROR_DS_DRA_SHUTDOWN: WIN32_ERROR = WIN32_ERROR(8463u32);
pub const ERROR_DS_DRA_INCOMPATIBLE_PARTIAL_SET: WIN32_ERROR = WIN32_ERROR(8464u32);
pub const ERROR_DS_DRA_SOURCE_IS_PARTIAL_REPLICA: WIN32_ERROR = WIN32_ERROR(8465u32);
pub const ERROR_DS_DRA_EXTN_CONNECTION_FAILED: WIN32_ERROR = WIN32_ERROR(8466u32);
pub const ERROR_DS_INSTALL_SCHEMA_MISMATCH: WIN32_ERROR = WIN32_ERROR(8467u32);
pub const ERROR_DS_DUP_LINK_ID: WIN32_ERROR = WIN32_ERROR(8468u32);
pub const ERROR_DS_NAME_ERROR_RESOLVING: WIN32_ERROR = WIN32_ERROR(8469u32);
pub const ERROR_DS_NAME_ERROR_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(8470u32);
pub const ERROR_DS_NAME_ERROR_NOT_UNIQUE: WIN32_ERROR = WIN32_ERROR(8471u32);
pub const ERROR_DS_NAME_ERROR_NO_MAPPING: WIN32_ERROR = WIN32_ERROR(8472u32);
pub const ERROR_DS_NAME_ERROR_DOMAIN_ONLY: WIN32_ERROR = WIN32_ERROR(8473u32);
pub const ERROR_DS_NAME_ERROR_NO_SYNTACTICAL_MAPPING: WIN32_ERROR = WIN32_ERROR(8474u32);
pub const ERROR_DS_CONSTRUCTED_ATT_MOD: WIN32_ERROR = WIN32_ERROR(8475u32);
pub const ERROR_DS_WRONG_OM_OBJ_CLASS: WIN32_ERROR = WIN32_ERROR(8476u32);
pub const ERROR_DS_DRA_REPL_PENDING: WIN32_ERROR = WIN32_ERROR(8477u32);
pub const ERROR_DS_DS_REQUIRED: WIN32_ERROR = WIN32_ERROR(8478u32);
pub const ERROR_DS_INVALID_LDAP_DISPLAY_NAME: WIN32_ERROR = WIN32_ERROR(8479u32);
pub const ERROR_DS_NON_BASE_SEARCH: WIN32_ERROR = WIN32_ERROR(8480u32);
pub const ERROR_DS_CANT_RETRIEVE_ATTS: WIN32_ERROR = WIN32_ERROR(8481u32);
pub const ERROR_DS_BACKLINK_WITHOUT_LINK: WIN32_ERROR = WIN32_ERROR(8482u32);
pub const ERROR_DS_EPOCH_MISMATCH: WIN32_ERROR = WIN32_ERROR(8483u32);
pub const ERROR_DS_SRC_NAME_MISMATCH: WIN32_ERROR = WIN32_ERROR(8484u32);
pub const ERROR_DS_SRC_AND_DST_NC_IDENTICAL: WIN32_ERROR = WIN32_ERROR(8485u32);
pub const ERROR_DS_DST_NC_MISMATCH: WIN32_ERROR = WIN32_ERROR(8486u32);
pub const ERROR_DS_NOT_AUTHORITIVE_FOR_DST_NC: WIN32_ERROR = WIN32_ERROR(8487u32);
pub const ERROR_DS_SRC_GUID_MISMATCH: WIN32_ERROR = WIN32_ERROR(8488u32);
pub const ERROR_DS_CANT_MOVE_DELETED_OBJECT: WIN32_ERROR = WIN32_ERROR(8489u32);
pub const ERROR_DS_PDC_OPERATION_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(8490u32);
pub const ERROR_DS_CROSS_DOMAIN_CLEANUP_REQD: WIN32_ERROR = WIN32_ERROR(8491u32);
pub const ERROR_DS_ILLEGAL_XDOM_MOVE_OPERATION: WIN32_ERROR = WIN32_ERROR(8492u32);
pub const ERROR_DS_CANT_WITH_ACCT_GROUP_MEMBERSHPS: WIN32_ERROR = WIN32_ERROR(8493u32);
pub const ERROR_DS_NC_MUST_HAVE_NC_PARENT: WIN32_ERROR = WIN32_ERROR(8494u32);
pub const ERROR_DS_CR_IMPOSSIBLE_TO_VALIDATE: WIN32_ERROR = WIN32_ERROR(8495u32);
pub const ERROR_DS_DST_DOMAIN_NOT_NATIVE: WIN32_ERROR = WIN32_ERROR(8496u32);
pub const ERROR_DS_MISSING_INFRASTRUCTURE_CONTAINER: WIN32_ERROR = WIN32_ERROR(8497u32);
pub const ERROR_DS_CANT_MOVE_ACCOUNT_GROUP: WIN32_ERROR = WIN32_ERROR(8498u32);
pub const ERROR_DS_CANT_MOVE_RESOURCE_GROUP: WIN32_ERROR = WIN32_ERROR(8499u32);
pub const ERROR_DS_INVALID_SEARCH_FLAG: WIN32_ERROR = WIN32_ERROR(8500u32);
pub const ERROR_DS_NO_TREE_DELETE_ABOVE_NC: WIN32_ERROR = WIN32_ERROR(8501u32);
pub const ERROR_DS_COULDNT_LOCK_TREE_FOR_DELETE: WIN32_ERROR = WIN32_ERROR(8502u32);
pub const ERROR_DS_COULDNT_IDENTIFY_OBJECTS_FOR_TREE_DELETE: WIN32_ERROR = WIN32_ERROR(8503u32);
pub const ERROR_DS_SAM_INIT_FAILURE: WIN32_ERROR = WIN32_ERROR(8504u32);
pub const ERROR_DS_SENSITIVE_GROUP_VIOLATION: WIN32_ERROR = WIN32_ERROR(8505u32);
pub const ERROR_DS_CANT_MOD_PRIMARYGROUPID: WIN32_ERROR = WIN32_ERROR(8506u32);
pub const ERROR_DS_ILLEGAL_BASE_SCHEMA_MOD: WIN32_ERROR = WIN32_ERROR(8507u32);
pub const ERROR_DS_NONSAFE_SCHEMA_CHANGE: WIN32_ERROR = WIN32_ERROR(8508u32);
pub const ERROR_DS_SCHEMA_UPDATE_DISALLOWED: WIN32_ERROR = WIN32_ERROR(8509u32);
pub const ERROR_DS_CANT_CREATE_UNDER_SCHEMA: WIN32_ERROR = WIN32_ERROR(8510u32);
pub const ERROR_DS_INSTALL_NO_SRC_SCH_VERSION: WIN32_ERROR = WIN32_ERROR(8511u32);
pub const ERROR_DS_INSTALL_NO_SCH_VERSION_IN_INIFILE: WIN32_ERROR = WIN32_ERROR(8512u32);
pub const ERROR_DS_INVALID_GROUP_TYPE: WIN32_ERROR = WIN32_ERROR(8513u32);
pub const ERROR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN: WIN32_ERROR = WIN32_ERROR(8514u32);
pub const ERROR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN: WIN32_ERROR = WIN32_ERROR(8515u32);
pub const ERROR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER: WIN32_ERROR = WIN32_ERROR(8516u32);
pub const ERROR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER: WIN32_ERROR = WIN32_ERROR(8517u32);
pub const ERROR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER: WIN32_ERROR = WIN32_ERROR(8518u32);
pub const ERROR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER: WIN32_ERROR = WIN32_ERROR(8519u32);
pub const ERROR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER: WIN32_ERROR = WIN32_ERROR(8520u32);
pub const ERROR_DS_HAVE_PRIMARY_MEMBERS: WIN32_ERROR = WIN32_ERROR(8521u32);
pub const ERROR_DS_STRING_SD_CONVERSION_FAILED: WIN32_ERROR = WIN32_ERROR(8522u32);
pub const ERROR_DS_NAMING_MASTER_GC: WIN32_ERROR = WIN32_ERROR(8523u32);
pub const ERROR_DS_DNS_LOOKUP_FAILURE: WIN32_ERROR = WIN32_ERROR(8524u32);
pub const ERROR_DS_COULDNT_UPDATE_SPNS: WIN32_ERROR = WIN32_ERROR(8525u32);
pub const ERROR_DS_CANT_RETRIEVE_SD: WIN32_ERROR = WIN32_ERROR(8526u32);
pub const ERROR_DS_KEY_NOT_UNIQUE: WIN32_ERROR = WIN32_ERROR(8527u32);
pub const ERROR_DS_WRONG_LINKED_ATT_SYNTAX: WIN32_ERROR = WIN32_ERROR(8528u32);
pub const ERROR_DS_SAM_NEED_BOOTKEY_PASSWORD: WIN32_ERROR = WIN32_ERROR(8529u32);
pub const ERROR_DS_SAM_NEED_BOOTKEY_FLOPPY: WIN32_ERROR = WIN32_ERROR(8530u32);
pub const ERROR_DS_CANT_START: WIN32_ERROR = WIN32_ERROR(8531u32);
pub const ERROR_DS_INIT_FAILURE: WIN32_ERROR = WIN32_ERROR(8532u32);
pub const ERROR_DS_NO_PKT_PRIVACY_ON_CONNECTION: WIN32_ERROR = WIN32_ERROR(8533u32);
pub const ERROR_DS_SOURCE_DOMAIN_IN_FOREST: WIN32_ERROR = WIN32_ERROR(8534u32);
pub const ERROR_DS_DESTINATION_DOMAIN_NOT_IN_FOREST: WIN32_ERROR = WIN32_ERROR(8535u32);
pub const ERROR_DS_DESTINATION_AUDITING_NOT_ENABLED: WIN32_ERROR = WIN32_ERROR(8536u32);
pub const ERROR_DS_CANT_FIND_DC_FOR_SRC_DOMAIN: WIN32_ERROR = WIN32_ERROR(8537u32);
pub const ERROR_DS_SRC_OBJ_NOT_GROUP_OR_USER: WIN32_ERROR = WIN32_ERROR(8538u32);
pub const ERROR_DS_SRC_SID_EXISTS_IN_FOREST: WIN32_ERROR = WIN32_ERROR(8539u32);
pub const ERROR_DS_SRC_AND_DST_OBJECT_CLASS_MISMATCH: WIN32_ERROR = WIN32_ERROR(8540u32);
pub const ERROR_SAM_INIT_FAILURE: WIN32_ERROR = WIN32_ERROR(8541u32);
pub const ERROR_DS_DRA_SCHEMA_INFO_SHIP: WIN32_ERROR = WIN32_ERROR(8542u32);
pub const ERROR_DS_DRA_SCHEMA_CONFLICT: WIN32_ERROR = WIN32_ERROR(8543u32);
pub const ERROR_DS_DRA_EARLIER_SCHEMA_CONFLICT: WIN32_ERROR = WIN32_ERROR(8544u32);
pub const ERROR_DS_DRA_OBJ_NC_MISMATCH: WIN32_ERROR = WIN32_ERROR(8545u32);
pub const ERROR_DS_NC_STILL_HAS_DSAS: WIN32_ERROR = WIN32_ERROR(8546u32);
pub const ERROR_DS_GC_REQUIRED: WIN32_ERROR = WIN32_ERROR(8547u32);
pub const ERROR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY: WIN32_ERROR = WIN32_ERROR(8548u32);
pub const ERROR_DS_NO_FPO_IN_UNIVERSAL_GROUPS: WIN32_ERROR = WIN32_ERROR(8549u32);
pub const ERROR_DS_CANT_ADD_TO_GC: WIN32_ERROR = WIN32_ERROR(8550u32);
pub const ERROR_DS_NO_CHECKPOINT_WITH_PDC: WIN32_ERROR = WIN32_ERROR(8551u32);
pub const ERROR_DS_SOURCE_AUDITING_NOT_ENABLED: WIN32_ERROR = WIN32_ERROR(8552u32);
pub const ERROR_DS_CANT_CREATE_IN_NONDOMAIN_NC: WIN32_ERROR = WIN32_ERROR(8553u32);
pub const ERROR_DS_INVALID_NAME_FOR_SPN: WIN32_ERROR = WIN32_ERROR(8554u32);
pub const ERROR_DS_FILTER_USES_CONTRUCTED_ATTRS: WIN32_ERROR = WIN32_ERROR(8555u32);
pub const ERROR_DS_UNICODEPWD_NOT_IN_QUOTES: WIN32_ERROR = WIN32_ERROR(8556u32);
pub const ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED: WIN32_ERROR = WIN32_ERROR(8557u32);
pub const ERROR_DS_MUST_BE_RUN_ON_DST_DC: WIN32_ERROR = WIN32_ERROR(8558u32);
pub const ERROR_DS_SRC_DC_MUST_BE_SP4_OR_GREATER: WIN32_ERROR = WIN32_ERROR(8559u32);
pub const ERROR_DS_CANT_TREE_DELETE_CRITICAL_OBJ: WIN32_ERROR = WIN32_ERROR(8560u32);
pub const ERROR_DS_INIT_FAILURE_CONSOLE: WIN32_ERROR = WIN32_ERROR(8561u32);
pub const ERROR_DS_SAM_INIT_FAILURE_CONSOLE: WIN32_ERROR = WIN32_ERROR(8562u32);
pub const ERROR_DS_FOREST_VERSION_TOO_HIGH: WIN32_ERROR = WIN32_ERROR(8563u32);
pub const ERROR_DS_DOMAIN_VERSION_TOO_HIGH: WIN32_ERROR = WIN32_ERROR(8564u32);
pub const ERROR_DS_FOREST_VERSION_TOO_LOW: WIN32_ERROR = WIN32_ERROR(8565u32);
pub const ERROR_DS_DOMAIN_VERSION_TOO_LOW: WIN32_ERROR = WIN32_ERROR(8566u32);
pub const ERROR_DS_INCOMPATIBLE_VERSION: WIN32_ERROR = WIN32_ERROR(8567u32);
pub const ERROR_DS_LOW_DSA_VERSION: WIN32_ERROR = WIN32_ERROR(8568u32);
pub const ERROR_DS_NO_BEHAVIOR_VERSION_IN_MIXEDDOMAIN: WIN32_ERROR = WIN32_ERROR(8569u32);
pub const ERROR_DS_NOT_SUPPORTED_SORT_ORDER: WIN32_ERROR = WIN32_ERROR(8570u32);
pub const ERROR_DS_NAME_NOT_UNIQUE: WIN32_ERROR = WIN32_ERROR(8571u32);
pub const ERROR_DS_MACHINE_ACCOUNT_CREATED_PRENT4: WIN32_ERROR = WIN32_ERROR(8572u32);
pub const ERROR_DS_OUT_OF_VERSION_STORE: WIN32_ERROR = WIN32_ERROR(8573u32);
pub const ERROR_DS_INCOMPATIBLE_CONTROLS_USED: WIN32_ERROR = WIN32_ERROR(8574u32);
pub const ERROR_DS_NO_REF_DOMAIN: WIN32_ERROR = WIN32_ERROR(8575u32);
pub const ERROR_DS_RESERVED_LINK_ID: WIN32_ERROR = WIN32_ERROR(8576u32);
pub const ERROR_DS_LINK_ID_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(8577u32);
pub const ERROR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER: WIN32_ERROR = WIN32_ERROR(8578u32);
pub const ERROR_DS_MODIFYDN_DISALLOWED_BY_INSTANCE_TYPE: WIN32_ERROR = WIN32_ERROR(8579u32);
pub const ERROR_DS_NO_OBJECT_MOVE_IN_SCHEMA_NC: WIN32_ERROR = WIN32_ERROR(8580u32);
pub const ERROR_DS_MODIFYDN_DISALLOWED_BY_FLAG: WIN32_ERROR = WIN32_ERROR(8581u32);
pub const ERROR_DS_MODIFYDN_WRONG_GRANDPARENT: WIN32_ERROR = WIN32_ERROR(8582u32);
pub const ERROR_DS_NAME_ERROR_TRUST_REFERRAL: WIN32_ERROR = WIN32_ERROR(8583u32);
pub const ERROR_NOT_SUPPORTED_ON_STANDARD_SERVER: WIN32_ERROR = WIN32_ERROR(8584u32);
pub const ERROR_DS_CANT_ACCESS_REMOTE_PART_OF_AD: WIN32_ERROR = WIN32_ERROR(8585u32);
pub const ERROR_DS_CR_IMPOSSIBLE_TO_VALIDATE_V2: WIN32_ERROR = WIN32_ERROR(8586u32);
pub const ERROR_DS_THREAD_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(8587u32);
pub const ERROR_DS_NOT_CLOSEST: WIN32_ERROR = WIN32_ERROR(8588u32);
pub const ERROR_DS_CANT_DERIVE_SPN_WITHOUT_SERVER_REF: WIN32_ERROR = WIN32_ERROR(8589u32);
pub const ERROR_DS_SINGLE_USER_MODE_FAILED: WIN32_ERROR = WIN32_ERROR(8590u32);
pub const ERROR_DS_NTDSCRIPT_SYNTAX_ERROR: WIN32_ERROR = WIN32_ERROR(8591u32);
pub const ERROR_DS_NTDSCRIPT_PROCESS_ERROR: WIN32_ERROR = WIN32_ERROR(8592u32);
pub const ERROR_DS_DIFFERENT_REPL_EPOCHS: WIN32_ERROR = WIN32_ERROR(8593u32);
pub const ERROR_DS_DRS_EXTENSIONS_CHANGED: WIN32_ERROR = WIN32_ERROR(8594u32);
pub const ERROR_DS_REPLICA_SET_CHANGE_NOT_ALLOWED_ON_DISABLED_CR: WIN32_ERROR = WIN32_ERROR(8595u32);
pub const ERROR_DS_NO_MSDS_INTID: WIN32_ERROR = WIN32_ERROR(8596u32);
pub const ERROR_DS_DUP_MSDS_INTID: WIN32_ERROR = WIN32_ERROR(8597u32);
pub const ERROR_DS_EXISTS_IN_RDNATTID: WIN32_ERROR = WIN32_ERROR(8598u32);
pub const ERROR_DS_AUTHORIZATION_FAILED: WIN32_ERROR = WIN32_ERROR(8599u32);
pub const ERROR_DS_INVALID_SCRIPT: WIN32_ERROR = WIN32_ERROR(8600u32);
pub const ERROR_DS_REMOTE_CROSSREF_OP_FAILED: WIN32_ERROR = WIN32_ERROR(8601u32);
pub const ERROR_DS_CROSS_REF_BUSY: WIN32_ERROR = WIN32_ERROR(8602u32);
pub const ERROR_DS_CANT_DERIVE_SPN_FOR_DELETED_DOMAIN: WIN32_ERROR = WIN32_ERROR(8603u32);
pub const ERROR_DS_CANT_DEMOTE_WITH_WRITEABLE_NC: WIN32_ERROR = WIN32_ERROR(8604u32);
pub const ERROR_DS_DUPLICATE_ID_FOUND: WIN32_ERROR = WIN32_ERROR(8605u32);
pub const ERROR_DS_INSUFFICIENT_ATTR_TO_CREATE_OBJECT: WIN32_ERROR = WIN32_ERROR(8606u32);
pub const ERROR_DS_GROUP_CONVERSION_ERROR: WIN32_ERROR = WIN32_ERROR(8607u32);
pub const ERROR_DS_CANT_MOVE_APP_BASIC_GROUP: WIN32_ERROR = WIN32_ERROR(8608u32);
pub const ERROR_DS_CANT_MOVE_APP_QUERY_GROUP: WIN32_ERROR = WIN32_ERROR(8609u32);
pub const ERROR_DS_ROLE_NOT_VERIFIED: WIN32_ERROR = WIN32_ERROR(8610u32);
pub const ERROR_DS_WKO_CONTAINER_CANNOT_BE_SPECIAL: WIN32_ERROR = WIN32_ERROR(8611u32);
pub const ERROR_DS_DOMAIN_RENAME_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(8612u32);
pub const ERROR_DS_EXISTING_AD_CHILD_NC: WIN32_ERROR = WIN32_ERROR(8613u32);
pub const ERROR_DS_REPL_LIFETIME_EXCEEDED: WIN32_ERROR = WIN32_ERROR(8614u32);
pub const ERROR_DS_DISALLOWED_IN_SYSTEM_CONTAINER: WIN32_ERROR = WIN32_ERROR(8615u32);
pub const ERROR_DS_LDAP_SEND_QUEUE_FULL: WIN32_ERROR = WIN32_ERROR(8616u32);
pub const ERROR_DS_DRA_OUT_SCHEDULE_WINDOW: WIN32_ERROR = WIN32_ERROR(8617u32);
pub const ERROR_DS_POLICY_NOT_KNOWN: WIN32_ERROR = WIN32_ERROR(8618u32);
pub const ERROR_NO_SITE_SETTINGS_OBJECT: WIN32_ERROR = WIN32_ERROR(8619u32);
pub const ERROR_NO_SECRETS: WIN32_ERROR = WIN32_ERROR(8620u32);
pub const ERROR_NO_WRITABLE_DC_FOUND: WIN32_ERROR = WIN32_ERROR(8621u32);
pub const ERROR_DS_NO_SERVER_OBJECT: WIN32_ERROR = WIN32_ERROR(8622u32);
pub const ERROR_DS_NO_NTDSA_OBJECT: WIN32_ERROR = WIN32_ERROR(8623u32);
pub const ERROR_DS_NON_ASQ_SEARCH: WIN32_ERROR = WIN32_ERROR(8624u32);
pub const ERROR_DS_AUDIT_FAILURE: WIN32_ERROR = WIN32_ERROR(8625u32);
pub const ERROR_DS_INVALID_SEARCH_FLAG_SUBTREE: WIN32_ERROR = WIN32_ERROR(8626u32);
pub const ERROR_DS_INVALID_SEARCH_FLAG_TUPLE: WIN32_ERROR = WIN32_ERROR(8627u32);
pub const ERROR_DS_HIERARCHY_TABLE_TOO_DEEP: WIN32_ERROR = WIN32_ERROR(8628u32);
pub const ERROR_DS_DRA_CORRUPT_UTD_VECTOR: WIN32_ERROR = WIN32_ERROR(8629u32);
pub const ERROR_DS_DRA_SECRETS_DENIED: WIN32_ERROR = WIN32_ERROR(8630u32);
pub const ERROR_DS_RESERVED_MAPI_ID: WIN32_ERROR = WIN32_ERROR(8631u32);
pub const ERROR_DS_MAPI_ID_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(8632u32);
pub const ERROR_DS_DRA_MISSING_KRBTGT_SECRET: WIN32_ERROR = WIN32_ERROR(8633u32);
pub const ERROR_DS_DOMAIN_NAME_EXISTS_IN_FOREST: WIN32_ERROR = WIN32_ERROR(8634u32);
pub const ERROR_DS_FLAT_NAME_EXISTS_IN_FOREST: WIN32_ERROR = WIN32_ERROR(8635u32);
pub const ERROR_INVALID_USER_PRINCIPAL_NAME: WIN32_ERROR = WIN32_ERROR(8636u32);
pub const ERROR_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS: WIN32_ERROR = WIN32_ERROR(8637u32);
pub const ERROR_DS_OID_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(8638u32);
pub const ERROR_DS_DRA_RECYCLED_TARGET: WIN32_ERROR = WIN32_ERROR(8639u32);
pub const ERROR_DS_DISALLOWED_NC_REDIRECT: WIN32_ERROR = WIN32_ERROR(8640u32);
pub const ERROR_DS_HIGH_ADLDS_FFL: WIN32_ERROR = WIN32_ERROR(8641u32);
pub const ERROR_DS_HIGH_DSA_VERSION: WIN32_ERROR = WIN32_ERROR(8642u32);
pub const ERROR_DS_LOW_ADLDS_FFL: WIN32_ERROR = WIN32_ERROR(8643u32);
pub const ERROR_DOMAIN_SID_SAME_AS_LOCAL_WORKSTATION: WIN32_ERROR = WIN32_ERROR(8644u32);
pub const ERROR_DS_UNDELETE_SAM_VALIDATION_FAILED: WIN32_ERROR = WIN32_ERROR(8645u32);
pub const ERROR_INCORRECT_ACCOUNT_TYPE: WIN32_ERROR = WIN32_ERROR(8646u32);
pub const ERROR_DS_SPN_VALUE_NOT_UNIQUE_IN_FOREST: WIN32_ERROR = WIN32_ERROR(8647u32);
pub const ERROR_DS_UPN_VALUE_NOT_UNIQUE_IN_FOREST: WIN32_ERROR = WIN32_ERROR(8648u32);
pub const ERROR_DS_MISSING_FOREST_TRUST: WIN32_ERROR = WIN32_ERROR(8649u32);
pub const ERROR_DS_VALUE_KEY_NOT_UNIQUE: WIN32_ERROR = WIN32_ERROR(8650u32);
pub const ERROR_WEAK_WHFBKEY_BLOCKED: WIN32_ERROR = WIN32_ERROR(8651u32);
pub const DNS_ERROR_RESPONSE_CODES_BASE: WIN32_ERROR = WIN32_ERROR(9000u32);
pub const DNS_ERROR_RCODE_NO_ERROR: WIN32_ERROR = WIN32_ERROR(0u32);
pub const DNS_ERROR_MASK: WIN32_ERROR = WIN32_ERROR(9000u32);
pub const DNS_ERROR_RCODE_FORMAT_ERROR: WIN32_ERROR = WIN32_ERROR(9001u32);
pub const DNS_ERROR_RCODE_SERVER_FAILURE: WIN32_ERROR = WIN32_ERROR(9002u32);
pub const DNS_ERROR_RCODE_NAME_ERROR: WIN32_ERROR = WIN32_ERROR(9003u32);
pub const DNS_ERROR_RCODE_NOT_IMPLEMENTED: WIN32_ERROR = WIN32_ERROR(9004u32);
pub const DNS_ERROR_RCODE_REFUSED: WIN32_ERROR = WIN32_ERROR(9005u32);
pub const DNS_ERROR_RCODE_YXDOMAIN: WIN32_ERROR = WIN32_ERROR(9006u32);
pub const DNS_ERROR_RCODE_YXRRSET: WIN32_ERROR = WIN32_ERROR(9007u32);
pub const DNS_ERROR_RCODE_NXRRSET: WIN32_ERROR = WIN32_ERROR(9008u32);
pub const DNS_ERROR_RCODE_NOTAUTH: WIN32_ERROR = WIN32_ERROR(9009u32);
pub const DNS_ERROR_RCODE_NOTZONE: WIN32_ERROR = WIN32_ERROR(9010u32);
pub const DNS_ERROR_RCODE_BADSIG: WIN32_ERROR = WIN32_ERROR(9016u32);
pub const DNS_ERROR_RCODE_BADKEY: WIN32_ERROR = WIN32_ERROR(9017u32);
pub const DNS_ERROR_RCODE_BADTIME: WIN32_ERROR = WIN32_ERROR(9018u32);
pub const DNS_ERROR_RCODE_LAST: WIN32_ERROR = WIN32_ERROR(9018u32);
pub const DNS_ERROR_DNSSEC_BASE: WIN32_ERROR = WIN32_ERROR(9100u32);
pub const DNS_ERROR_KEYMASTER_REQUIRED: WIN32_ERROR = WIN32_ERROR(9101u32);
pub const DNS_ERROR_NOT_ALLOWED_ON_SIGNED_ZONE: WIN32_ERROR = WIN32_ERROR(9102u32);
pub const DNS_ERROR_NSEC3_INCOMPATIBLE_WITH_RSA_SHA1: WIN32_ERROR = WIN32_ERROR(9103u32);
pub const DNS_ERROR_NOT_ENOUGH_SIGNING_KEY_DESCRIPTORS: WIN32_ERROR = WIN32_ERROR(9104u32);
pub const DNS_ERROR_UNSUPPORTED_ALGORITHM: WIN32_ERROR = WIN32_ERROR(9105u32);
pub const DNS_ERROR_INVALID_KEY_SIZE: WIN32_ERROR = WIN32_ERROR(9106u32);
pub const DNS_ERROR_SIGNING_KEY_NOT_ACCESSIBLE: WIN32_ERROR = WIN32_ERROR(9107u32);
pub const DNS_ERROR_KSP_DOES_NOT_SUPPORT_PROTECTION: WIN32_ERROR = WIN32_ERROR(9108u32);
pub const DNS_ERROR_UNEXPECTED_DATA_PROTECTION_ERROR: WIN32_ERROR = WIN32_ERROR(9109u32);
pub const DNS_ERROR_UNEXPECTED_CNG_ERROR: WIN32_ERROR = WIN32_ERROR(9110u32);
pub const DNS_ERROR_UNKNOWN_SIGNING_PARAMETER_VERSION: WIN32_ERROR = WIN32_ERROR(9111u32);
pub const DNS_ERROR_KSP_NOT_ACCESSIBLE: WIN32_ERROR = WIN32_ERROR(9112u32);
pub const DNS_ERROR_TOO_MANY_SKDS: WIN32_ERROR = WIN32_ERROR(9113u32);
pub const DNS_ERROR_INVALID_ROLLOVER_PERIOD: WIN32_ERROR = WIN32_ERROR(9114u32);
pub const DNS_ERROR_INVALID_INITIAL_ROLLOVER_OFFSET: WIN32_ERROR = WIN32_ERROR(9115u32);
pub const DNS_ERROR_ROLLOVER_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(9116u32);
pub const DNS_ERROR_STANDBY_KEY_NOT_PRESENT: WIN32_ERROR = WIN32_ERROR(9117u32);
pub const DNS_ERROR_NOT_ALLOWED_ON_ZSK: WIN32_ERROR = WIN32_ERROR(9118u32);
pub const DNS_ERROR_NOT_ALLOWED_ON_ACTIVE_SKD: WIN32_ERROR = WIN32_ERROR(9119u32);
pub const DNS_ERROR_ROLLOVER_ALREADY_QUEUED: WIN32_ERROR = WIN32_ERROR(9120u32);
pub const DNS_ERROR_NOT_ALLOWED_ON_UNSIGNED_ZONE: WIN32_ERROR = WIN32_ERROR(9121u32);
pub const DNS_ERROR_BAD_KEYMASTER: WIN32_ERROR = WIN32_ERROR(9122u32);
pub const DNS_ERROR_INVALID_SIGNATURE_VALIDITY_PERIOD: WIN32_ERROR = WIN32_ERROR(9123u32);
pub const DNS_ERROR_INVALID_NSEC3_ITERATION_COUNT: WIN32_ERROR = WIN32_ERROR(9124u32);
pub const DNS_ERROR_DNSSEC_IS_DISABLED: WIN32_ERROR = WIN32_ERROR(9125u32);
pub const DNS_ERROR_INVALID_XML: WIN32_ERROR = WIN32_ERROR(9126u32);
pub const DNS_ERROR_NO_VALID_TRUST_ANCHORS: WIN32_ERROR = WIN32_ERROR(9127u32);
pub const DNS_ERROR_ROLLOVER_NOT_POKEABLE: WIN32_ERROR = WIN32_ERROR(9128u32);
pub const DNS_ERROR_NSEC3_NAME_COLLISION: WIN32_ERROR = WIN32_ERROR(9129u32);
pub const DNS_ERROR_NSEC_INCOMPATIBLE_WITH_NSEC3_RSA_SHA1: WIN32_ERROR = WIN32_ERROR(9130u32);
pub const DNS_ERROR_PACKET_FMT_BASE: WIN32_ERROR = WIN32_ERROR(9500u32);
pub const DNS_ERROR_BAD_PACKET: WIN32_ERROR = WIN32_ERROR(9502u32);
pub const DNS_ERROR_NO_PACKET: WIN32_ERROR = WIN32_ERROR(9503u32);
pub const DNS_ERROR_RCODE: WIN32_ERROR = WIN32_ERROR(9504u32);
pub const DNS_ERROR_UNSECURE_PACKET: WIN32_ERROR = WIN32_ERROR(9505u32);
pub const DNS_ERROR_NO_MEMORY: WIN32_ERROR = WIN32_ERROR(14u32);
pub const DNS_ERROR_INVALID_NAME: WIN32_ERROR = WIN32_ERROR(123u32);
pub const DNS_ERROR_INVALID_DATA: WIN32_ERROR = WIN32_ERROR(13u32);
pub const DNS_ERROR_GENERAL_API_BASE: WIN32_ERROR = WIN32_ERROR(9550u32);
pub const DNS_ERROR_INVALID_TYPE: WIN32_ERROR = WIN32_ERROR(9551u32);
pub const DNS_ERROR_INVALID_IP_ADDRESS: WIN32_ERROR = WIN32_ERROR(9552u32);
pub const DNS_ERROR_INVALID_PROPERTY: WIN32_ERROR = WIN32_ERROR(9553u32);
pub const DNS_ERROR_TRY_AGAIN_LATER: WIN32_ERROR = WIN32_ERROR(9554u32);
pub const DNS_ERROR_NOT_UNIQUE: WIN32_ERROR = WIN32_ERROR(9555u32);
pub const DNS_ERROR_NON_RFC_NAME: WIN32_ERROR = WIN32_ERROR(9556u32);
pub const DNS_ERROR_INVALID_NAME_CHAR: WIN32_ERROR = WIN32_ERROR(9560u32);
pub const DNS_ERROR_NUMERIC_NAME: WIN32_ERROR = WIN32_ERROR(9561u32);
pub const DNS_ERROR_NOT_ALLOWED_ON_ROOT_SERVER: WIN32_ERROR = WIN32_ERROR(9562u32);
pub const DNS_ERROR_NOT_ALLOWED_UNDER_DELEGATION: WIN32_ERROR = WIN32_ERROR(9563u32);
pub const DNS_ERROR_CANNOT_FIND_ROOT_HINTS: WIN32_ERROR = WIN32_ERROR(9564u32);
pub const DNS_ERROR_INCONSISTENT_ROOT_HINTS: WIN32_ERROR = WIN32_ERROR(9565u32);
pub const DNS_ERROR_DWORD_VALUE_TOO_SMALL: WIN32_ERROR = WIN32_ERROR(9566u32);
pub const DNS_ERROR_DWORD_VALUE_TOO_LARGE: WIN32_ERROR = WIN32_ERROR(9567u32);
pub const DNS_ERROR_BACKGROUND_LOADING: WIN32_ERROR = WIN32_ERROR(9568u32);
pub const DNS_ERROR_NOT_ALLOWED_ON_RODC: WIN32_ERROR = WIN32_ERROR(9569u32);
pub const DNS_ERROR_NOT_ALLOWED_UNDER_DNAME: WIN32_ERROR = WIN32_ERROR(9570u32);
pub const DNS_ERROR_DELEGATION_REQUIRED: WIN32_ERROR = WIN32_ERROR(9571u32);
pub const DNS_ERROR_INVALID_POLICY_TABLE: WIN32_ERROR = WIN32_ERROR(9572u32);
pub const DNS_ERROR_ADDRESS_REQUIRED: WIN32_ERROR = WIN32_ERROR(9573u32);
pub const DNS_ERROR_ZONE_BASE: WIN32_ERROR = WIN32_ERROR(9600u32);
pub const DNS_ERROR_ZONE_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(9601u32);
pub const DNS_ERROR_NO_ZONE_INFO: WIN32_ERROR = WIN32_ERROR(9602u32);
pub const DNS_ERROR_INVALID_ZONE_OPERATION: WIN32_ERROR = WIN32_ERROR(9603u32);
pub const DNS_ERROR_ZONE_CONFIGURATION_ERROR: WIN32_ERROR = WIN32_ERROR(9604u32);
pub const DNS_ERROR_ZONE_HAS_NO_SOA_RECORD: WIN32_ERROR = WIN32_ERROR(9605u32);
pub const DNS_ERROR_ZONE_HAS_NO_NS_RECORDS: WIN32_ERROR = WIN32_ERROR(9606u32);
pub const DNS_ERROR_ZONE_LOCKED: WIN32_ERROR = WIN32_ERROR(9607u32);
pub const DNS_ERROR_ZONE_CREATION_FAILED: WIN32_ERROR = WIN32_ERROR(9608u32);
pub const DNS_ERROR_ZONE_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(9609u32);
pub const DNS_ERROR_AUTOZONE_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(9610u32);
pub const DNS_ERROR_INVALID_ZONE_TYPE: WIN32_ERROR = WIN32_ERROR(9611u32);
pub const DNS_ERROR_SECONDARY_REQUIRES_MASTER_IP: WIN32_ERROR = WIN32_ERROR(9612u32);
pub const DNS_ERROR_ZONE_NOT_SECONDARY: WIN32_ERROR = WIN32_ERROR(9613u32);
pub const DNS_ERROR_NEED_SECONDARY_ADDRESSES: WIN32_ERROR = WIN32_ERROR(9614u32);
pub const DNS_ERROR_WINS_INIT_FAILED: WIN32_ERROR = WIN32_ERROR(9615u32);
pub const DNS_ERROR_NEED_WINS_SERVERS: WIN32_ERROR = WIN32_ERROR(9616u32);
pub const DNS_ERROR_NBSTAT_INIT_FAILED: WIN32_ERROR = WIN32_ERROR(9617u32);
pub const DNS_ERROR_SOA_DELETE_INVALID: WIN32_ERROR = WIN32_ERROR(9618u32);
pub const DNS_ERROR_FORWARDER_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(9619u32);
pub const DNS_ERROR_ZONE_REQUIRES_MASTER_IP: WIN32_ERROR = WIN32_ERROR(9620u32);
pub const DNS_ERROR_ZONE_IS_SHUTDOWN: WIN32_ERROR = WIN32_ERROR(9621u32);
pub const DNS_ERROR_ZONE_LOCKED_FOR_SIGNING: WIN32_ERROR = WIN32_ERROR(9622u32);
pub const DNS_ERROR_DATAFILE_BASE: WIN32_ERROR = WIN32_ERROR(9650u32);
pub const DNS_ERROR_PRIMARY_REQUIRES_DATAFILE: WIN32_ERROR = WIN32_ERROR(9651u32);
pub const DNS_ERROR_INVALID_DATAFILE_NAME: WIN32_ERROR = WIN32_ERROR(9652u32);
pub const DNS_ERROR_DATAFILE_OPEN_FAILURE: WIN32_ERROR = WIN32_ERROR(9653u32);
pub const DNS_ERROR_FILE_WRITEBACK_FAILED: WIN32_ERROR = WIN32_ERROR(9654u32);
pub const DNS_ERROR_DATAFILE_PARSING: WIN32_ERROR = WIN32_ERROR(9655u32);
pub const DNS_ERROR_DATABASE_BASE: WIN32_ERROR = WIN32_ERROR(9700u32);
pub const DNS_ERROR_RECORD_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(9701u32);
pub const DNS_ERROR_RECORD_FORMAT: WIN32_ERROR = WIN32_ERROR(9702u32);
pub const DNS_ERROR_NODE_CREATION_FAILED: WIN32_ERROR = WIN32_ERROR(9703u32);
pub const DNS_ERROR_UNKNOWN_RECORD_TYPE: WIN32_ERROR = WIN32_ERROR(9704u32);
pub const DNS_ERROR_RECORD_TIMED_OUT: WIN32_ERROR = WIN32_ERROR(9705u32);
pub const DNS_ERROR_NAME_NOT_IN_ZONE: WIN32_ERROR = WIN32_ERROR(9706u32);
pub const DNS_ERROR_CNAME_LOOP: WIN32_ERROR = WIN32_ERROR(9707u32);
pub const DNS_ERROR_NODE_IS_CNAME: WIN32_ERROR = WIN32_ERROR(9708u32);
pub const DNS_ERROR_CNAME_COLLISION: WIN32_ERROR = WIN32_ERROR(9709u32);
pub const DNS_ERROR_RECORD_ONLY_AT_ZONE_ROOT: WIN32_ERROR = WIN32_ERROR(9710u32);
pub const DNS_ERROR_RECORD_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(9711u32);
pub const DNS_ERROR_SECONDARY_DATA: WIN32_ERROR = WIN32_ERROR(9712u32);
pub const DNS_ERROR_NO_CREATE_CACHE_DATA: WIN32_ERROR = WIN32_ERROR(9713u32);
pub const DNS_ERROR_NAME_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(9714u32);
pub const DNS_ERROR_DS_UNAVAILABLE: WIN32_ERROR = WIN32_ERROR(9717u32);
pub const DNS_ERROR_DS_ZONE_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(9718u32);
pub const DNS_ERROR_NO_BOOTFILE_IF_DS_ZONE: WIN32_ERROR = WIN32_ERROR(9719u32);
pub const DNS_ERROR_NODE_IS_DNAME: WIN32_ERROR = WIN32_ERROR(9720u32);
pub const DNS_ERROR_DNAME_COLLISION: WIN32_ERROR = WIN32_ERROR(9721u32);
pub const DNS_ERROR_ALIAS_LOOP: WIN32_ERROR = WIN32_ERROR(9722u32);
pub const DNS_ERROR_OPERATION_BASE: WIN32_ERROR = WIN32_ERROR(9750u32);
pub const DNS_ERROR_AXFR: WIN32_ERROR = WIN32_ERROR(9752u32);
pub const DNS_ERROR_SECURE_BASE: WIN32_ERROR = WIN32_ERROR(9800u32);
pub const DNS_ERROR_SETUP_BASE: WIN32_ERROR = WIN32_ERROR(9850u32);
pub const DNS_ERROR_NO_TCPIP: WIN32_ERROR = WIN32_ERROR(9851u32);
pub const DNS_ERROR_NO_DNS_SERVERS: WIN32_ERROR = WIN32_ERROR(9852u32);
pub const DNS_ERROR_DP_BASE: WIN32_ERROR = WIN32_ERROR(9900u32);
pub const DNS_ERROR_DP_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(9901u32);
pub const DNS_ERROR_DP_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(9902u32);
pub const DNS_ERROR_DP_NOT_ENLISTED: WIN32_ERROR = WIN32_ERROR(9903u32);
pub const DNS_ERROR_DP_ALREADY_ENLISTED: WIN32_ERROR = WIN32_ERROR(9904u32);
pub const DNS_ERROR_DP_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(9905u32);
pub const DNS_ERROR_DP_FSMO_ERROR: WIN32_ERROR = WIN32_ERROR(9906u32);
pub const DNS_ERROR_RRL_NOT_ENABLED: WIN32_ERROR = WIN32_ERROR(9911u32);
pub const DNS_ERROR_RRL_INVALID_WINDOW_SIZE: WIN32_ERROR = WIN32_ERROR(9912u32);
pub const DNS_ERROR_RRL_INVALID_IPV4_PREFIX: WIN32_ERROR = WIN32_ERROR(9913u32);
pub const DNS_ERROR_RRL_INVALID_IPV6_PREFIX: WIN32_ERROR = WIN32_ERROR(9914u32);
pub const DNS_ERROR_RRL_INVALID_TC_RATE: WIN32_ERROR = WIN32_ERROR(9915u32);
pub const DNS_ERROR_RRL_INVALID_LEAK_RATE: WIN32_ERROR = WIN32_ERROR(9916u32);
pub const DNS_ERROR_RRL_LEAK_RATE_LESSTHAN_TC_RATE: WIN32_ERROR = WIN32_ERROR(9917u32);
pub const DNS_ERROR_VIRTUALIZATION_INSTANCE_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(9921u32);
pub const DNS_ERROR_VIRTUALIZATION_INSTANCE_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(9922u32);
pub const DNS_ERROR_VIRTUALIZATION_TREE_LOCKED: WIN32_ERROR = WIN32_ERROR(9923u32);
pub const DNS_ERROR_INVAILD_VIRTUALIZATION_INSTANCE_NAME: WIN32_ERROR = WIN32_ERROR(9924u32);
pub const DNS_ERROR_DEFAULT_VIRTUALIZATION_INSTANCE: WIN32_ERROR = WIN32_ERROR(9925u32);
pub const DNS_ERROR_ZONESCOPE_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(9951u32);
pub const DNS_ERROR_ZONESCOPE_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(9952u32);
pub const DNS_ERROR_DEFAULT_ZONESCOPE: WIN32_ERROR = WIN32_ERROR(9953u32);
pub const DNS_ERROR_INVALID_ZONESCOPE_NAME: WIN32_ERROR = WIN32_ERROR(9954u32);
pub const DNS_ERROR_NOT_ALLOWED_WITH_ZONESCOPES: WIN32_ERROR = WIN32_ERROR(9955u32);
pub const DNS_ERROR_LOAD_ZONESCOPE_FAILED: WIN32_ERROR = WIN32_ERROR(9956u32);
pub const DNS_ERROR_ZONESCOPE_FILE_WRITEBACK_FAILED: WIN32_ERROR = WIN32_ERROR(9957u32);
pub const DNS_ERROR_INVALID_SCOPE_NAME: WIN32_ERROR = WIN32_ERROR(9958u32);
pub const DNS_ERROR_SCOPE_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(9959u32);
pub const DNS_ERROR_DEFAULT_SCOPE: WIN32_ERROR = WIN32_ERROR(9960u32);
pub const DNS_ERROR_INVALID_SCOPE_OPERATION: WIN32_ERROR = WIN32_ERROR(9961u32);
pub const DNS_ERROR_SCOPE_LOCKED: WIN32_ERROR = WIN32_ERROR(9962u32);
pub const DNS_ERROR_SCOPE_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(9963u32);
pub const DNS_ERROR_POLICY_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(9971u32);
pub const DNS_ERROR_POLICY_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(9972u32);
pub const DNS_ERROR_POLICY_INVALID_CRITERIA: WIN32_ERROR = WIN32_ERROR(9973u32);
pub const DNS_ERROR_POLICY_INVALID_SETTINGS: WIN32_ERROR = WIN32_ERROR(9974u32);
pub const DNS_ERROR_CLIENT_SUBNET_IS_ACCESSED: WIN32_ERROR = WIN32_ERROR(9975u32);
pub const DNS_ERROR_CLIENT_SUBNET_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(9976u32);
pub const DNS_ERROR_CLIENT_SUBNET_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(9977u32);
pub const DNS_ERROR_SUBNET_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(9978u32);
pub const DNS_ERROR_SUBNET_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(9979u32);
pub const DNS_ERROR_POLICY_LOCKED: WIN32_ERROR = WIN32_ERROR(9980u32);
pub const DNS_ERROR_POLICY_INVALID_WEIGHT: WIN32_ERROR = WIN32_ERROR(9981u32);
pub const DNS_ERROR_POLICY_INVALID_NAME: WIN32_ERROR = WIN32_ERROR(9982u32);
pub const DNS_ERROR_POLICY_MISSING_CRITERIA: WIN32_ERROR = WIN32_ERROR(9983u32);
pub const DNS_ERROR_INVALID_CLIENT_SUBNET_NAME: WIN32_ERROR = WIN32_ERROR(9984u32);
pub const DNS_ERROR_POLICY_PROCESSING_ORDER_INVALID: WIN32_ERROR = WIN32_ERROR(9985u32);
pub const DNS_ERROR_POLICY_SCOPE_MISSING: WIN32_ERROR = WIN32_ERROR(9986u32);
pub const DNS_ERROR_POLICY_SCOPE_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(9987u32);
pub const DNS_ERROR_SERVERSCOPE_IS_REFERENCED: WIN32_ERROR = WIN32_ERROR(9988u32);
pub const DNS_ERROR_ZONESCOPE_IS_REFERENCED: WIN32_ERROR = WIN32_ERROR(9989u32);
pub const DNS_ERROR_POLICY_INVALID_CRITERIA_CLIENT_SUBNET: WIN32_ERROR = WIN32_ERROR(9990u32);
pub const DNS_ERROR_POLICY_INVALID_CRITERIA_TRANSPORT_PROTOCOL: WIN32_ERROR = WIN32_ERROR(9991u32);
pub const DNS_ERROR_POLICY_INVALID_CRITERIA_NETWORK_PROTOCOL: WIN32_ERROR = WIN32_ERROR(9992u32);
pub const DNS_ERROR_POLICY_INVALID_CRITERIA_INTERFACE: WIN32_ERROR = WIN32_ERROR(9993u32);
pub const DNS_ERROR_POLICY_INVALID_CRITERIA_FQDN: WIN32_ERROR = WIN32_ERROR(9994u32);
pub const DNS_ERROR_POLICY_INVALID_CRITERIA_QUERY_TYPE: WIN32_ERROR = WIN32_ERROR(9995u32);
pub const DNS_ERROR_POLICY_INVALID_CRITERIA_TIME_OF_DAY: WIN32_ERROR = WIN32_ERROR(9996u32);
pub const ERROR_IPSEC_QM_POLICY_EXISTS: WIN32_ERROR = WIN32_ERROR(13000u32);
pub const ERROR_IPSEC_QM_POLICY_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(13001u32);
pub const ERROR_IPSEC_QM_POLICY_IN_USE: WIN32_ERROR = WIN32_ERROR(13002u32);
pub const ERROR_IPSEC_MM_POLICY_EXISTS: WIN32_ERROR = WIN32_ERROR(13003u32);
pub const ERROR_IPSEC_MM_POLICY_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(13004u32);
pub const ERROR_IPSEC_MM_POLICY_IN_USE: WIN32_ERROR = WIN32_ERROR(13005u32);
pub const ERROR_IPSEC_MM_FILTER_EXISTS: WIN32_ERROR = WIN32_ERROR(13006u32);
pub const ERROR_IPSEC_MM_FILTER_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(13007u32);
pub const ERROR_IPSEC_TRANSPORT_FILTER_EXISTS: WIN32_ERROR = WIN32_ERROR(13008u32);
pub const ERROR_IPSEC_TRANSPORT_FILTER_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(13009u32);
pub const ERROR_IPSEC_MM_AUTH_EXISTS: WIN32_ERROR = WIN32_ERROR(13010u32);
pub const ERROR_IPSEC_MM_AUTH_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(13011u32);
pub const ERROR_IPSEC_MM_AUTH_IN_USE: WIN32_ERROR = WIN32_ERROR(13012u32);
pub const ERROR_IPSEC_DEFAULT_MM_POLICY_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(13013u32);
pub const ERROR_IPSEC_DEFAULT_MM_AUTH_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(13014u32);
pub const ERROR_IPSEC_DEFAULT_QM_POLICY_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(13015u32);
pub const ERROR_IPSEC_TUNNEL_FILTER_EXISTS: WIN32_ERROR = WIN32_ERROR(13016u32);
pub const ERROR_IPSEC_TUNNEL_FILTER_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(13017u32);
pub const ERROR_IPSEC_MM_FILTER_PENDING_DELETION: WIN32_ERROR = WIN32_ERROR(13018u32);
pub const ERROR_IPSEC_TRANSPORT_FILTER_PENDING_DELETION: WIN32_ERROR = WIN32_ERROR(13019u32);
pub const ERROR_IPSEC_TUNNEL_FILTER_PENDING_DELETION: WIN32_ERROR = WIN32_ERROR(13020u32);
pub const ERROR_IPSEC_MM_POLICY_PENDING_DELETION: WIN32_ERROR = WIN32_ERROR(13021u32);
pub const ERROR_IPSEC_MM_AUTH_PENDING_DELETION: WIN32_ERROR = WIN32_ERROR(13022u32);
pub const ERROR_IPSEC_QM_POLICY_PENDING_DELETION: WIN32_ERROR = WIN32_ERROR(13023u32);
pub const ERROR_IPSEC_IKE_NEG_STATUS_BEGIN: WIN32_ERROR = WIN32_ERROR(13800u32);
pub const ERROR_IPSEC_IKE_AUTH_FAIL: WIN32_ERROR = WIN32_ERROR(13801u32);
pub const ERROR_IPSEC_IKE_ATTRIB_FAIL: WIN32_ERROR = WIN32_ERROR(13802u32);
pub const ERROR_IPSEC_IKE_NEGOTIATION_PENDING: WIN32_ERROR = WIN32_ERROR(13803u32);
pub const ERROR_IPSEC_IKE_GENERAL_PROCESSING_ERROR: WIN32_ERROR = WIN32_ERROR(13804u32);
pub const ERROR_IPSEC_IKE_TIMED_OUT: WIN32_ERROR = WIN32_ERROR(13805u32);
pub const ERROR_IPSEC_IKE_NO_CERT: WIN32_ERROR = WIN32_ERROR(13806u32);
pub const ERROR_IPSEC_IKE_SA_DELETED: WIN32_ERROR = WIN32_ERROR(13807u32);
pub const ERROR_IPSEC_IKE_SA_REAPED: WIN32_ERROR = WIN32_ERROR(13808u32);
pub const ERROR_IPSEC_IKE_MM_ACQUIRE_DROP: WIN32_ERROR = WIN32_ERROR(13809u32);
pub const ERROR_IPSEC_IKE_QM_ACQUIRE_DROP: WIN32_ERROR = WIN32_ERROR(13810u32);
pub const ERROR_IPSEC_IKE_QUEUE_DROP_MM: WIN32_ERROR = WIN32_ERROR(13811u32);
pub const ERROR_IPSEC_IKE_QUEUE_DROP_NO_MM: WIN32_ERROR = WIN32_ERROR(13812u32);
pub const ERROR_IPSEC_IKE_DROP_NO_RESPONSE: WIN32_ERROR = WIN32_ERROR(13813u32);
pub const ERROR_IPSEC_IKE_MM_DELAY_DROP: WIN32_ERROR = WIN32_ERROR(13814u32);
pub const ERROR_IPSEC_IKE_QM_DELAY_DROP: WIN32_ERROR = WIN32_ERROR(13815u32);
pub const ERROR_IPSEC_IKE_ERROR: WIN32_ERROR = WIN32_ERROR(13816u32);
pub const ERROR_IPSEC_IKE_CRL_FAILED: WIN32_ERROR = WIN32_ERROR(13817u32);
pub const ERROR_IPSEC_IKE_INVALID_KEY_USAGE: WIN32_ERROR = WIN32_ERROR(13818u32);
pub const ERROR_IPSEC_IKE_INVALID_CERT_TYPE: WIN32_ERROR = WIN32_ERROR(13819u32);
pub const ERROR_IPSEC_IKE_NO_PRIVATE_KEY: WIN32_ERROR = WIN32_ERROR(13820u32);
pub const ERROR_IPSEC_IKE_SIMULTANEOUS_REKEY: WIN32_ERROR = WIN32_ERROR(13821u32);
pub const ERROR_IPSEC_IKE_DH_FAIL: WIN32_ERROR = WIN32_ERROR(13822u32);
pub const ERROR_IPSEC_IKE_CRITICAL_PAYLOAD_NOT_RECOGNIZED: WIN32_ERROR = WIN32_ERROR(13823u32);
pub const ERROR_IPSEC_IKE_INVALID_HEADER: WIN32_ERROR = WIN32_ERROR(13824u32);
pub const ERROR_IPSEC_IKE_NO_POLICY: WIN32_ERROR = WIN32_ERROR(13825u32);
pub const ERROR_IPSEC_IKE_INVALID_SIGNATURE: WIN32_ERROR = WIN32_ERROR(13826u32);
pub const ERROR_IPSEC_IKE_KERBEROS_ERROR: WIN32_ERROR = WIN32_ERROR(13827u32);
pub const ERROR_IPSEC_IKE_NO_PUBLIC_KEY: WIN32_ERROR = WIN32_ERROR(13828u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR: WIN32_ERROR = WIN32_ERROR(13829u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_SA: WIN32_ERROR = WIN32_ERROR(13830u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_PROP: WIN32_ERROR = WIN32_ERROR(13831u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_TRANS: WIN32_ERROR = WIN32_ERROR(13832u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_KE: WIN32_ERROR = WIN32_ERROR(13833u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_ID: WIN32_ERROR = WIN32_ERROR(13834u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_CERT: WIN32_ERROR = WIN32_ERROR(13835u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_CERT_REQ: WIN32_ERROR = WIN32_ERROR(13836u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_HASH: WIN32_ERROR = WIN32_ERROR(13837u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_SIG: WIN32_ERROR = WIN32_ERROR(13838u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_NONCE: WIN32_ERROR = WIN32_ERROR(13839u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_NOTIFY: WIN32_ERROR = WIN32_ERROR(13840u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_DELETE: WIN32_ERROR = WIN32_ERROR(13841u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_VENDOR: WIN32_ERROR = WIN32_ERROR(13842u32);
pub const ERROR_IPSEC_IKE_INVALID_PAYLOAD: WIN32_ERROR = WIN32_ERROR(13843u32);
pub const ERROR_IPSEC_IKE_LOAD_SOFT_SA: WIN32_ERROR = WIN32_ERROR(13844u32);
pub const ERROR_IPSEC_IKE_SOFT_SA_TORN_DOWN: WIN32_ERROR = WIN32_ERROR(13845u32);
pub const ERROR_IPSEC_IKE_INVALID_COOKIE: WIN32_ERROR = WIN32_ERROR(13846u32);
pub const ERROR_IPSEC_IKE_NO_PEER_CERT: WIN32_ERROR = WIN32_ERROR(13847u32);
pub const ERROR_IPSEC_IKE_PEER_CRL_FAILED: WIN32_ERROR = WIN32_ERROR(13848u32);
pub const ERROR_IPSEC_IKE_POLICY_CHANGE: WIN32_ERROR = WIN32_ERROR(13849u32);
pub const ERROR_IPSEC_IKE_NO_MM_POLICY: WIN32_ERROR = WIN32_ERROR(13850u32);
pub const ERROR_IPSEC_IKE_NOTCBPRIV: WIN32_ERROR = WIN32_ERROR(13851u32);
pub const ERROR_IPSEC_IKE_SECLOADFAIL: WIN32_ERROR = WIN32_ERROR(13852u32);
pub const ERROR_IPSEC_IKE_FAILSSPINIT: WIN32_ERROR = WIN32_ERROR(13853u32);
pub const ERROR_IPSEC_IKE_FAILQUERYSSP: WIN32_ERROR = WIN32_ERROR(13854u32);
pub const ERROR_IPSEC_IKE_SRVACQFAIL: WIN32_ERROR = WIN32_ERROR(13855u32);
pub const ERROR_IPSEC_IKE_SRVQUERYCRED: WIN32_ERROR = WIN32_ERROR(13856u32);
pub const ERROR_IPSEC_IKE_GETSPIFAIL: WIN32_ERROR = WIN32_ERROR(13857u32);
pub const ERROR_IPSEC_IKE_INVALID_FILTER: WIN32_ERROR = WIN32_ERROR(13858u32);
pub const ERROR_IPSEC_IKE_OUT_OF_MEMORY: WIN32_ERROR = WIN32_ERROR(13859u32);
pub const ERROR_IPSEC_IKE_ADD_UPDATE_KEY_FAILED: WIN32_ERROR = WIN32_ERROR(13860u32);
pub const ERROR_IPSEC_IKE_INVALID_POLICY: WIN32_ERROR = WIN32_ERROR(13861u32);
pub const ERROR_IPSEC_IKE_UNKNOWN_DOI: WIN32_ERROR = WIN32_ERROR(13862u32);
pub const ERROR_IPSEC_IKE_INVALID_SITUATION: WIN32_ERROR = WIN32_ERROR(13863u32);
pub const ERROR_IPSEC_IKE_DH_FAILURE: WIN32_ERROR = WIN32_ERROR(13864u32);
pub const ERROR_IPSEC_IKE_INVALID_GROUP: WIN32_ERROR = WIN32_ERROR(13865u32);
pub const ERROR_IPSEC_IKE_ENCRYPT: WIN32_ERROR = WIN32_ERROR(13866u32);
pub const ERROR_IPSEC_IKE_DECRYPT: WIN32_ERROR = WIN32_ERROR(13867u32);
pub const ERROR_IPSEC_IKE_POLICY_MATCH: WIN32_ERROR = WIN32_ERROR(13868u32);
pub const ERROR_IPSEC_IKE_UNSUPPORTED_ID: WIN32_ERROR = WIN32_ERROR(13869u32);
pub const ERROR_IPSEC_IKE_INVALID_HASH: WIN32_ERROR = WIN32_ERROR(13870u32);
pub const ERROR_IPSEC_IKE_INVALID_HASH_ALG: WIN32_ERROR = WIN32_ERROR(13871u32);
pub const ERROR_IPSEC_IKE_INVALID_HASH_SIZE: WIN32_ERROR = WIN32_ERROR(13872u32);
pub const ERROR_IPSEC_IKE_INVALID_ENCRYPT_ALG: WIN32_ERROR = WIN32_ERROR(13873u32);
pub const ERROR_IPSEC_IKE_INVALID_AUTH_ALG: WIN32_ERROR = WIN32_ERROR(13874u32);
pub const ERROR_IPSEC_IKE_INVALID_SIG: WIN32_ERROR = WIN32_ERROR(13875u32);
pub const ERROR_IPSEC_IKE_LOAD_FAILED: WIN32_ERROR = WIN32_ERROR(13876u32);
pub const ERROR_IPSEC_IKE_RPC_DELETE: WIN32_ERROR = WIN32_ERROR(13877u32);
pub const ERROR_IPSEC_IKE_BENIGN_REINIT: WIN32_ERROR = WIN32_ERROR(13878u32);
pub const ERROR_IPSEC_IKE_INVALID_RESPONDER_LIFETIME_NOTIFY: WIN32_ERROR = WIN32_ERROR(13879u32);
pub const ERROR_IPSEC_IKE_INVALID_MAJOR_VERSION: WIN32_ERROR = WIN32_ERROR(13880u32);
pub const ERROR_IPSEC_IKE_INVALID_CERT_KEYLEN: WIN32_ERROR = WIN32_ERROR(13881u32);
pub const ERROR_IPSEC_IKE_MM_LIMIT: WIN32_ERROR = WIN32_ERROR(13882u32);
pub const ERROR_IPSEC_IKE_NEGOTIATION_DISABLED: WIN32_ERROR = WIN32_ERROR(13883u32);
pub const ERROR_IPSEC_IKE_QM_LIMIT: WIN32_ERROR = WIN32_ERROR(13884u32);
pub const ERROR_IPSEC_IKE_MM_EXPIRED: WIN32_ERROR = WIN32_ERROR(13885u32);
pub const ERROR_IPSEC_IKE_PEER_MM_ASSUMED_INVALID: WIN32_ERROR = WIN32_ERROR(13886u32);
pub const ERROR_IPSEC_IKE_CERT_CHAIN_POLICY_MISMATCH: WIN32_ERROR = WIN32_ERROR(13887u32);
pub const ERROR_IPSEC_IKE_UNEXPECTED_MESSAGE_ID: WIN32_ERROR = WIN32_ERROR(13888u32);
pub const ERROR_IPSEC_IKE_INVALID_AUTH_PAYLOAD: WIN32_ERROR = WIN32_ERROR(13889u32);
pub const ERROR_IPSEC_IKE_DOS_COOKIE_SENT: WIN32_ERROR = WIN32_ERROR(13890u32);
pub const ERROR_IPSEC_IKE_SHUTTING_DOWN: WIN32_ERROR = WIN32_ERROR(13891u32);
pub const ERROR_IPSEC_IKE_CGA_AUTH_FAILED: WIN32_ERROR = WIN32_ERROR(13892u32);
pub const ERROR_IPSEC_IKE_PROCESS_ERR_NATOA: WIN32_ERROR = WIN32_ERROR(13893u32);
pub const ERROR_IPSEC_IKE_INVALID_MM_FOR_QM: WIN32_ERROR = WIN32_ERROR(13894u32);
pub const ERROR_IPSEC_IKE_QM_EXPIRED: WIN32_ERROR = WIN32_ERROR(13895u32);
pub const ERROR_IPSEC_IKE_TOO_MANY_FILTERS: WIN32_ERROR = WIN32_ERROR(13896u32);
pub const ERROR_IPSEC_IKE_NEG_STATUS_END: WIN32_ERROR = WIN32_ERROR(13897u32);
pub const ERROR_IPSEC_IKE_KILL_DUMMY_NAP_TUNNEL: WIN32_ERROR = WIN32_ERROR(13898u32);
pub const ERROR_IPSEC_IKE_INNER_IP_ASSIGNMENT_FAILURE: WIN32_ERROR = WIN32_ERROR(13899u32);
pub const ERROR_IPSEC_IKE_REQUIRE_CP_PAYLOAD_MISSING: WIN32_ERROR = WIN32_ERROR(13900u32);
pub const ERROR_IPSEC_KEY_MODULE_IMPERSONATION_NEGOTIATION_PENDING: WIN32_ERROR = WIN32_ERROR(13901u32);
pub const ERROR_IPSEC_IKE_COEXISTENCE_SUPPRESS: WIN32_ERROR = WIN32_ERROR(13902u32);
pub const ERROR_IPSEC_IKE_RATELIMIT_DROP: WIN32_ERROR = WIN32_ERROR(13903u32);
pub const ERROR_IPSEC_IKE_PEER_DOESNT_SUPPORT_MOBIKE: WIN32_ERROR = WIN32_ERROR(13904u32);
pub const ERROR_IPSEC_IKE_AUTHORIZATION_FAILURE: WIN32_ERROR = WIN32_ERROR(13905u32);
pub const ERROR_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_FAILURE: WIN32_ERROR = WIN32_ERROR(13906u32);
pub const ERROR_IPSEC_IKE_AUTHORIZATION_FAILURE_WITH_OPTIONAL_RETRY: WIN32_ERROR = WIN32_ERROR(13907u32);
pub const ERROR_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_AND_CERTMAP_FAILURE: WIN32_ERROR = WIN32_ERROR(13908u32);
pub const ERROR_IPSEC_IKE_NEG_STATUS_EXTENDED_END: WIN32_ERROR = WIN32_ERROR(13909u32);
pub const ERROR_IPSEC_BAD_SPI: WIN32_ERROR = WIN32_ERROR(13910u32);
pub const ERROR_IPSEC_SA_LIFETIME_EXPIRED: WIN32_ERROR = WIN32_ERROR(13911u32);
pub const ERROR_IPSEC_WRONG_SA: WIN32_ERROR = WIN32_ERROR(13912u32);
pub const ERROR_IPSEC_REPLAY_CHECK_FAILED: WIN32_ERROR = WIN32_ERROR(13913u32);
pub const ERROR_IPSEC_INVALID_PACKET: WIN32_ERROR = WIN32_ERROR(13914u32);
pub const ERROR_IPSEC_INTEGRITY_CHECK_FAILED: WIN32_ERROR = WIN32_ERROR(13915u32);
pub const ERROR_IPSEC_CLEAR_TEXT_DROP: WIN32_ERROR = WIN32_ERROR(13916u32);
pub const ERROR_IPSEC_AUTH_FIREWALL_DROP: WIN32_ERROR = WIN32_ERROR(13917u32);
pub const ERROR_IPSEC_THROTTLE_DROP: WIN32_ERROR = WIN32_ERROR(13918u32);
pub const ERROR_IPSEC_DOSP_BLOCK: WIN32_ERROR = WIN32_ERROR(13925u32);
pub const ERROR_IPSEC_DOSP_RECEIVED_MULTICAST: WIN32_ERROR = WIN32_ERROR(13926u32);
pub const ERROR_IPSEC_DOSP_INVALID_PACKET: WIN32_ERROR = WIN32_ERROR(13927u32);
pub const ERROR_IPSEC_DOSP_STATE_LOOKUP_FAILED: WIN32_ERROR = WIN32_ERROR(13928u32);
pub const ERROR_IPSEC_DOSP_MAX_ENTRIES: WIN32_ERROR = WIN32_ERROR(13929u32);
pub const ERROR_IPSEC_DOSP_KEYMOD_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(13930u32);
pub const ERROR_IPSEC_DOSP_NOT_INSTALLED: WIN32_ERROR = WIN32_ERROR(13931u32);
pub const ERROR_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES: WIN32_ERROR = WIN32_ERROR(13932u32);
pub const ERROR_SXS_SECTION_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(14000u32);
pub const ERROR_SXS_CANT_GEN_ACTCTX: WIN32_ERROR = WIN32_ERROR(14001u32);
pub const ERROR_SXS_INVALID_ACTCTXDATA_FORMAT: WIN32_ERROR = WIN32_ERROR(14002u32);
pub const ERROR_SXS_ASSEMBLY_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(14003u32);
pub const ERROR_SXS_MANIFEST_FORMAT_ERROR: WIN32_ERROR = WIN32_ERROR(14004u32);
pub const ERROR_SXS_MANIFEST_PARSE_ERROR: WIN32_ERROR = WIN32_ERROR(14005u32);
pub const ERROR_SXS_ACTIVATION_CONTEXT_DISABLED: WIN32_ERROR = WIN32_ERROR(14006u32);
pub const ERROR_SXS_KEY_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(14007u32);
pub const ERROR_SXS_VERSION_CONFLICT: WIN32_ERROR = WIN32_ERROR(14008u32);
pub const ERROR_SXS_WRONG_SECTION_TYPE: WIN32_ERROR = WIN32_ERROR(14009u32);
pub const ERROR_SXS_THREAD_QUERIES_DISABLED: WIN32_ERROR = WIN32_ERROR(14010u32);
pub const ERROR_SXS_PROCESS_DEFAULT_ALREADY_SET: WIN32_ERROR = WIN32_ERROR(14011u32);
pub const ERROR_SXS_UNKNOWN_ENCODING_GROUP: WIN32_ERROR = WIN32_ERROR(14012u32);
pub const ERROR_SXS_UNKNOWN_ENCODING: WIN32_ERROR = WIN32_ERROR(14013u32);
pub const ERROR_SXS_INVALID_XML_NAMESPACE_URI: WIN32_ERROR = WIN32_ERROR(14014u32);
pub const ERROR_SXS_ROOT_MANIFEST_DEPENDENCY_NOT_INSTALLED: WIN32_ERROR = WIN32_ERROR(14015u32);
pub const ERROR_SXS_LEAF_MANIFEST_DEPENDENCY_NOT_INSTALLED: WIN32_ERROR = WIN32_ERROR(14016u32);
pub const ERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE: WIN32_ERROR = WIN32_ERROR(14017u32);
pub const ERROR_SXS_MANIFEST_MISSING_REQUIRED_DEFAULT_NAMESPACE: WIN32_ERROR = WIN32_ERROR(14018u32);
pub const ERROR_SXS_MANIFEST_INVALID_REQUIRED_DEFAULT_NAMESPACE: WIN32_ERROR = WIN32_ERROR(14019u32);
pub const ERROR_SXS_PRIVATE_MANIFEST_CROSS_PATH_WITH_REPARSE_POINT: WIN32_ERROR = WIN32_ERROR(14020u32);
pub const ERROR_SXS_DUPLICATE_DLL_NAME: WIN32_ERROR = WIN32_ERROR(14021u32);
pub const ERROR_SXS_DUPLICATE_WINDOWCLASS_NAME: WIN32_ERROR = WIN32_ERROR(14022u32);
pub const ERROR_SXS_DUPLICATE_CLSID: WIN32_ERROR = WIN32_ERROR(14023u32);
pub const ERROR_SXS_DUPLICATE_IID: WIN32_ERROR = WIN32_ERROR(14024u32);
pub const ERROR_SXS_DUPLICATE_TLBID: WIN32_ERROR = WIN32_ERROR(14025u32);
pub const ERROR_SXS_DUPLICATE_PROGID: WIN32_ERROR = WIN32_ERROR(14026u32);
pub const ERROR_SXS_DUPLICATE_ASSEMBLY_NAME: WIN32_ERROR = WIN32_ERROR(14027u32);
pub const ERROR_SXS_FILE_HASH_MISMATCH: WIN32_ERROR = WIN32_ERROR(14028u32);
pub const ERROR_SXS_POLICY_PARSE_ERROR: WIN32_ERROR = WIN32_ERROR(14029u32);
pub const ERROR_SXS_XML_E_MISSINGQUOTE: WIN32_ERROR = WIN32_ERROR(14030u32);
pub const ERROR_SXS_XML_E_COMMENTSYNTAX: WIN32_ERROR = WIN32_ERROR(14031u32);
pub const ERROR_SXS_XML_E_BADSTARTNAMECHAR: WIN32_ERROR = WIN32_ERROR(14032u32);
pub const ERROR_SXS_XML_E_BADNAMECHAR: WIN32_ERROR = WIN32_ERROR(14033u32);
pub const ERROR_SXS_XML_E_BADCHARINSTRING: WIN32_ERROR = WIN32_ERROR(14034u32);
pub const ERROR_SXS_XML_E_XMLDECLSYNTAX: WIN32_ERROR = WIN32_ERROR(14035u32);
pub const ERROR_SXS_XML_E_BADCHARDATA: WIN32_ERROR = WIN32_ERROR(14036u32);
pub const ERROR_SXS_XML_E_MISSINGWHITESPACE: WIN32_ERROR = WIN32_ERROR(14037u32);
pub const ERROR_SXS_XML_E_EXPECTINGTAGEND: WIN32_ERROR = WIN32_ERROR(14038u32);
pub const ERROR_SXS_XML_E_MISSINGSEMICOLON: WIN32_ERROR = WIN32_ERROR(14039u32);
pub const ERROR_SXS_XML_E_UNBALANCEDPAREN: WIN32_ERROR = WIN32_ERROR(14040u32);
pub const ERROR_SXS_XML_E_INTERNALERROR: WIN32_ERROR = WIN32_ERROR(14041u32);
pub const ERROR_SXS_XML_E_UNEXPECTED_WHITESPACE: WIN32_ERROR = WIN32_ERROR(14042u32);
pub const ERROR_SXS_XML_E_INCOMPLETE_ENCODING: WIN32_ERROR = WIN32_ERROR(14043u32);
pub const ERROR_SXS_XML_E_MISSING_PAREN: WIN32_ERROR = WIN32_ERROR(14044u32);
pub const ERROR_SXS_XML_E_EXPECTINGCLOSEQUOTE: WIN32_ERROR = WIN32_ERROR(14045u32);
pub const ERROR_SXS_XML_E_MULTIPLE_COLONS: WIN32_ERROR = WIN32_ERROR(14046u32);
pub const ERROR_SXS_XML_E_INVALID_DECIMAL: WIN32_ERROR = WIN32_ERROR(14047u32);
pub const ERROR_SXS_XML_E_INVALID_HEXIDECIMAL: WIN32_ERROR = WIN32_ERROR(14048u32);
pub const ERROR_SXS_XML_E_INVALID_UNICODE: WIN32_ERROR = WIN32_ERROR(14049u32);
pub const ERROR_SXS_XML_E_WHITESPACEORQUESTIONMARK: WIN32_ERROR = WIN32_ERROR(14050u32);
pub const ERROR_SXS_XML_E_UNEXPECTEDENDTAG: WIN32_ERROR = WIN32_ERROR(14051u32);
pub const ERROR_SXS_XML_E_UNCLOSEDTAG: WIN32_ERROR = WIN32_ERROR(14052u32);
pub const ERROR_SXS_XML_E_DUPLICATEATTRIBUTE: WIN32_ERROR = WIN32_ERROR(14053u32);
pub const ERROR_SXS_XML_E_MULTIPLEROOTS: WIN32_ERROR = WIN32_ERROR(14054u32);
pub const ERROR_SXS_XML_E_INVALIDATROOTLEVEL: WIN32_ERROR = WIN32_ERROR(14055u32);
pub const ERROR_SXS_XML_E_BADXMLDECL: WIN32_ERROR = WIN32_ERROR(14056u32);
pub const ERROR_SXS_XML_E_MISSINGROOT: WIN32_ERROR = WIN32_ERROR(14057u32);
pub const ERROR_SXS_XML_E_UNEXPECTEDEOF: WIN32_ERROR = WIN32_ERROR(14058u32);
pub const ERROR_SXS_XML_E_BADPEREFINSUBSET: WIN32_ERROR = WIN32_ERROR(14059u32);
pub const ERROR_SXS_XML_E_UNCLOSEDSTARTTAG: WIN32_ERROR = WIN32_ERROR(14060u32);
pub const ERROR_SXS_XML_E_UNCLOSEDENDTAG: WIN32_ERROR = WIN32_ERROR(14061u32);
pub const ERROR_SXS_XML_E_UNCLOSEDSTRING: WIN32_ERROR = WIN32_ERROR(14062u32);
pub const ERROR_SXS_XML_E_UNCLOSEDCOMMENT: WIN32_ERROR = WIN32_ERROR(14063u32);
pub const ERROR_SXS_XML_E_UNCLOSEDDECL: WIN32_ERROR = WIN32_ERROR(14064u32);
pub const ERROR_SXS_XML_E_UNCLOSEDCDATA: WIN32_ERROR = WIN32_ERROR(14065u32);
pub const ERROR_SXS_XML_E_RESERVEDNAMESPACE: WIN32_ERROR = WIN32_ERROR(14066u32);
pub const ERROR_SXS_XML_E_INVALIDENCODING: WIN32_ERROR = WIN32_ERROR(14067u32);
pub const ERROR_SXS_XML_E_INVALIDSWITCH: WIN32_ERROR = WIN32_ERROR(14068u32);
pub const ERROR_SXS_XML_E_BADXMLCASE: WIN32_ERROR = WIN32_ERROR(14069u32);
pub const ERROR_SXS_XML_E_INVALID_STANDALONE: WIN32_ERROR = WIN32_ERROR(14070u32);
pub const ERROR_SXS_XML_E_UNEXPECTED_STANDALONE: WIN32_ERROR = WIN32_ERROR(14071u32);
pub const ERROR_SXS_XML_E_INVALID_VERSION: WIN32_ERROR = WIN32_ERROR(14072u32);
pub const ERROR_SXS_XML_E_MISSINGEQUALS: WIN32_ERROR = WIN32_ERROR(14073u32);
pub const ERROR_SXS_PROTECTION_RECOVERY_FAILED: WIN32_ERROR = WIN32_ERROR(14074u32);
pub const ERROR_SXS_PROTECTION_PUBLIC_KEY_TOO_SHORT: WIN32_ERROR = WIN32_ERROR(14075u32);
pub const ERROR_SXS_PROTECTION_CATALOG_NOT_VALID: WIN32_ERROR = WIN32_ERROR(14076u32);
pub const ERROR_SXS_UNTRANSLATABLE_HRESULT: WIN32_ERROR = WIN32_ERROR(14077u32);
pub const ERROR_SXS_PROTECTION_CATALOG_FILE_MISSING: WIN32_ERROR = WIN32_ERROR(14078u32);
pub const ERROR_SXS_MISSING_ASSEMBLY_IDENTITY_ATTRIBUTE: WIN32_ERROR = WIN32_ERROR(14079u32);
pub const ERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAME: WIN32_ERROR = WIN32_ERROR(14080u32);
pub const ERROR_SXS_ASSEMBLY_MISSING: WIN32_ERROR = WIN32_ERROR(14081u32);
pub const ERROR_SXS_CORRUPT_ACTIVATION_STACK: WIN32_ERROR = WIN32_ERROR(14082u32);
pub const ERROR_SXS_CORRUPTION: WIN32_ERROR = WIN32_ERROR(14083u32);
pub const ERROR_SXS_EARLY_DEACTIVATION: WIN32_ERROR = WIN32_ERROR(14084u32);
pub const ERROR_SXS_INVALID_DEACTIVATION: WIN32_ERROR = WIN32_ERROR(14085u32);
pub const ERROR_SXS_MULTIPLE_DEACTIVATION: WIN32_ERROR = WIN32_ERROR(14086u32);
pub const ERROR_SXS_PROCESS_TERMINATION_REQUESTED: WIN32_ERROR = WIN32_ERROR(14087u32);
pub const ERROR_SXS_RELEASE_ACTIVATION_CONTEXT: WIN32_ERROR = WIN32_ERROR(14088u32);
pub const ERROR_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY: WIN32_ERROR = WIN32_ERROR(14089u32);
pub const ERROR_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE: WIN32_ERROR = WIN32_ERROR(14090u32);
pub const ERROR_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME: WIN32_ERROR = WIN32_ERROR(14091u32);
pub const ERROR_SXS_IDENTITY_DUPLICATE_ATTRIBUTE: WIN32_ERROR = WIN32_ERROR(14092u32);
pub const ERROR_SXS_IDENTITY_PARSE_ERROR: WIN32_ERROR = WIN32_ERROR(14093u32);
pub const ERROR_MALFORMED_SUBSTITUTION_STRING: WIN32_ERROR = WIN32_ERROR(14094u32);
pub const ERROR_SXS_INCORRECT_PUBLIC_KEY_TOKEN: WIN32_ERROR = WIN32_ERROR(14095u32);
pub const ERROR_UNMAPPED_SUBSTITUTION_STRING: WIN32_ERROR = WIN32_ERROR(14096u32);
pub const ERROR_SXS_ASSEMBLY_NOT_LOCKED: WIN32_ERROR = WIN32_ERROR(14097u32);
pub const ERROR_SXS_COMPONENT_STORE_CORRUPT: WIN32_ERROR = WIN32_ERROR(14098u32);
pub const ERROR_ADVANCED_INSTALLER_FAILED: WIN32_ERROR = WIN32_ERROR(14099u32);
pub const ERROR_XML_ENCODING_MISMATCH: WIN32_ERROR = WIN32_ERROR(14100u32);
pub const ERROR_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT: WIN32_ERROR = WIN32_ERROR(14101u32);
pub const ERROR_SXS_IDENTITIES_DIFFERENT: WIN32_ERROR = WIN32_ERROR(14102u32);
pub const ERROR_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT: WIN32_ERROR = WIN32_ERROR(14103u32);
pub const ERROR_SXS_FILE_NOT_PART_OF_ASSEMBLY: WIN32_ERROR = WIN32_ERROR(14104u32);
pub const ERROR_SXS_MANIFEST_TOO_BIG: WIN32_ERROR = WIN32_ERROR(14105u32);
pub const ERROR_SXS_SETTING_NOT_REGISTERED: WIN32_ERROR = WIN32_ERROR(14106u32);
pub const ERROR_SXS_TRANSACTION_CLOSURE_INCOMPLETE: WIN32_ERROR = WIN32_ERROR(14107u32);
pub const ERROR_SMI_PRIMITIVE_INSTALLER_FAILED: WIN32_ERROR = WIN32_ERROR(14108u32);
pub const ERROR_GENERIC_COMMAND_FAILED: WIN32_ERROR = WIN32_ERROR(14109u32);
pub const ERROR_SXS_FILE_HASH_MISSING: WIN32_ERROR = WIN32_ERROR(14110u32);
pub const ERROR_SXS_DUPLICATE_ACTIVATABLE_CLASS: WIN32_ERROR = WIN32_ERROR(14111u32);
pub const ERROR_EVT_INVALID_CHANNEL_PATH: WIN32_ERROR = WIN32_ERROR(15000u32);
pub const ERROR_EVT_INVALID_QUERY: WIN32_ERROR = WIN32_ERROR(15001u32);
pub const ERROR_EVT_PUBLISHER_METADATA_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15002u32);
pub const ERROR_EVT_EVENT_TEMPLATE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15003u32);
pub const ERROR_EVT_INVALID_PUBLISHER_NAME: WIN32_ERROR = WIN32_ERROR(15004u32);
pub const ERROR_EVT_INVALID_EVENT_DATA: WIN32_ERROR = WIN32_ERROR(15005u32);
pub const ERROR_EVT_CHANNEL_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15007u32);
pub const ERROR_EVT_MALFORMED_XML_TEXT: WIN32_ERROR = WIN32_ERROR(15008u32);
pub const ERROR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL: WIN32_ERROR = WIN32_ERROR(15009u32);
pub const ERROR_EVT_CONFIGURATION_ERROR: WIN32_ERROR = WIN32_ERROR(15010u32);
pub const ERROR_EVT_QUERY_RESULT_STALE: WIN32_ERROR = WIN32_ERROR(15011u32);
pub const ERROR_EVT_QUERY_RESULT_INVALID_POSITION: WIN32_ERROR = WIN32_ERROR(15012u32);
pub const ERROR_EVT_NON_VALIDATING_MSXML: WIN32_ERROR = WIN32_ERROR(15013u32);
pub const ERROR_EVT_FILTER_ALREADYSCOPED: WIN32_ERROR = WIN32_ERROR(15014u32);
pub const ERROR_EVT_FILTER_NOTELTSET: WIN32_ERROR = WIN32_ERROR(15015u32);
pub const ERROR_EVT_FILTER_INVARG: WIN32_ERROR = WIN32_ERROR(15016u32);
pub const ERROR_EVT_FILTER_INVTEST: WIN32_ERROR = WIN32_ERROR(15017u32);
pub const ERROR_EVT_FILTER_INVTYPE: WIN32_ERROR = WIN32_ERROR(15018u32);
pub const ERROR_EVT_FILTER_PARSEERR: WIN32_ERROR = WIN32_ERROR(15019u32);
pub const ERROR_EVT_FILTER_UNSUPPORTEDOP: WIN32_ERROR = WIN32_ERROR(15020u32);
pub const ERROR_EVT_FILTER_UNEXPECTEDTOKEN: WIN32_ERROR = WIN32_ERROR(15021u32);
pub const ERROR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL: WIN32_ERROR = WIN32_ERROR(15022u32);
pub const ERROR_EVT_INVALID_CHANNEL_PROPERTY_VALUE: WIN32_ERROR = WIN32_ERROR(15023u32);
pub const ERROR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE: WIN32_ERROR = WIN32_ERROR(15024u32);
pub const ERROR_EVT_CHANNEL_CANNOT_ACTIVATE: WIN32_ERROR = WIN32_ERROR(15025u32);
pub const ERROR_EVT_FILTER_TOO_COMPLEX: WIN32_ERROR = WIN32_ERROR(15026u32);
pub const ERROR_EVT_MESSAGE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15027u32);
pub const ERROR_EVT_MESSAGE_ID_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15028u32);
pub const ERROR_EVT_UNRESOLVED_VALUE_INSERT: WIN32_ERROR = WIN32_ERROR(15029u32);
pub const ERROR_EVT_UNRESOLVED_PARAMETER_INSERT: WIN32_ERROR = WIN32_ERROR(15030u32);
pub const ERROR_EVT_MAX_INSERTS_REACHED: WIN32_ERROR = WIN32_ERROR(15031u32);
pub const ERROR_EVT_EVENT_DEFINITION_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15032u32);
pub const ERROR_EVT_MESSAGE_LOCALE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15033u32);
pub const ERROR_EVT_VERSION_TOO_OLD: WIN32_ERROR = WIN32_ERROR(15034u32);
pub const ERROR_EVT_VERSION_TOO_NEW: WIN32_ERROR = WIN32_ERROR(15035u32);
pub const ERROR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY: WIN32_ERROR = WIN32_ERROR(15036u32);
pub const ERROR_EVT_PUBLISHER_DISABLED: WIN32_ERROR = WIN32_ERROR(15037u32);
pub const ERROR_EVT_FILTER_OUT_OF_RANGE: WIN32_ERROR = WIN32_ERROR(15038u32);
pub const ERROR_EC_SUBSCRIPTION_CANNOT_ACTIVATE: WIN32_ERROR = WIN32_ERROR(15080u32);
pub const ERROR_EC_LOG_DISABLED: WIN32_ERROR = WIN32_ERROR(15081u32);
pub const ERROR_EC_CIRCULAR_FORWARDING: WIN32_ERROR = WIN32_ERROR(15082u32);
pub const ERROR_EC_CREDSTORE_FULL: WIN32_ERROR = WIN32_ERROR(15083u32);
pub const ERROR_EC_CRED_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15084u32);
pub const ERROR_EC_NO_ACTIVE_CHANNEL: WIN32_ERROR = WIN32_ERROR(15085u32);
pub const ERROR_MUI_FILE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15100u32);
pub const ERROR_MUI_INVALID_FILE: WIN32_ERROR = WIN32_ERROR(15101u32);
pub const ERROR_MUI_INVALID_RC_CONFIG: WIN32_ERROR = WIN32_ERROR(15102u32);
pub const ERROR_MUI_INVALID_LOCALE_NAME: WIN32_ERROR = WIN32_ERROR(15103u32);
pub const ERROR_MUI_INVALID_ULTIMATEFALLBACK_NAME: WIN32_ERROR = WIN32_ERROR(15104u32);
pub const ERROR_MUI_FILE_NOT_LOADED: WIN32_ERROR = WIN32_ERROR(15105u32);
pub const ERROR_RESOURCE_ENUM_USER_STOP: WIN32_ERROR = WIN32_ERROR(15106u32);
pub const ERROR_MUI_INTLSETTINGS_UILANG_NOT_INSTALLED: WIN32_ERROR = WIN32_ERROR(15107u32);
pub const ERROR_MUI_INTLSETTINGS_INVALID_LOCALE_NAME: WIN32_ERROR = WIN32_ERROR(15108u32);
pub const ERROR_MRM_RUNTIME_NO_DEFAULT_OR_NEUTRAL_RESOURCE: WIN32_ERROR = WIN32_ERROR(15110u32);
pub const ERROR_MRM_INVALID_PRICONFIG: WIN32_ERROR = WIN32_ERROR(15111u32);
pub const ERROR_MRM_INVALID_FILE_TYPE: WIN32_ERROR = WIN32_ERROR(15112u32);
pub const ERROR_MRM_UNKNOWN_QUALIFIER: WIN32_ERROR = WIN32_ERROR(15113u32);
pub const ERROR_MRM_INVALID_QUALIFIER_VALUE: WIN32_ERROR = WIN32_ERROR(15114u32);
pub const ERROR_MRM_NO_CANDIDATE: WIN32_ERROR = WIN32_ERROR(15115u32);
pub const ERROR_MRM_NO_MATCH_OR_DEFAULT_CANDIDATE: WIN32_ERROR = WIN32_ERROR(15116u32);
pub const ERROR_MRM_RESOURCE_TYPE_MISMATCH: WIN32_ERROR = WIN32_ERROR(15117u32);
pub const ERROR_MRM_DUPLICATE_MAP_NAME: WIN32_ERROR = WIN32_ERROR(15118u32);
pub const ERROR_MRM_DUPLICATE_ENTRY: WIN32_ERROR = WIN32_ERROR(15119u32);
pub const ERROR_MRM_INVALID_RESOURCE_IDENTIFIER: WIN32_ERROR = WIN32_ERROR(15120u32);
pub const ERROR_MRM_FILEPATH_TOO_LONG: WIN32_ERROR = WIN32_ERROR(15121u32);
pub const ERROR_MRM_UNSUPPORTED_DIRECTORY_TYPE: WIN32_ERROR = WIN32_ERROR(15122u32);
pub const ERROR_MRM_INVALID_PRI_FILE: WIN32_ERROR = WIN32_ERROR(15126u32);
pub const ERROR_MRM_NAMED_RESOURCE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15127u32);
pub const ERROR_MRM_MAP_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15135u32);
pub const ERROR_MRM_UNSUPPORTED_PROFILE_TYPE: WIN32_ERROR = WIN32_ERROR(15136u32);
pub const ERROR_MRM_INVALID_QUALIFIER_OPERATOR: WIN32_ERROR = WIN32_ERROR(15137u32);
pub const ERROR_MRM_INDETERMINATE_QUALIFIER_VALUE: WIN32_ERROR = WIN32_ERROR(15138u32);
pub const ERROR_MRM_AUTOMERGE_ENABLED: WIN32_ERROR = WIN32_ERROR(15139u32);
pub const ERROR_MRM_TOO_MANY_RESOURCES: WIN32_ERROR = WIN32_ERROR(15140u32);
pub const ERROR_MRM_UNSUPPORTED_FILE_TYPE_FOR_MERGE: WIN32_ERROR = WIN32_ERROR(15141u32);
pub const ERROR_MRM_UNSUPPORTED_FILE_TYPE_FOR_LOAD_UNLOAD_PRI_FILE: WIN32_ERROR = WIN32_ERROR(15142u32);
pub const ERROR_MRM_NO_CURRENT_VIEW_ON_THREAD: WIN32_ERROR = WIN32_ERROR(15143u32);
pub const ERROR_DIFFERENT_PROFILE_RESOURCE_MANAGER_EXIST: WIN32_ERROR = WIN32_ERROR(15144u32);
pub const ERROR_OPERATION_NOT_ALLOWED_FROM_SYSTEM_COMPONENT: WIN32_ERROR = WIN32_ERROR(15145u32);
pub const ERROR_MRM_DIRECT_REF_TO_NON_DEFAULT_RESOURCE: WIN32_ERROR = WIN32_ERROR(15146u32);
pub const ERROR_MRM_GENERATION_COUNT_MISMATCH: WIN32_ERROR = WIN32_ERROR(15147u32);
pub const ERROR_PRI_MERGE_VERSION_MISMATCH: WIN32_ERROR = WIN32_ERROR(15148u32);
pub const ERROR_PRI_MERGE_MISSING_SCHEMA: WIN32_ERROR = WIN32_ERROR(15149u32);
pub const ERROR_PRI_MERGE_LOAD_FILE_FAILED: WIN32_ERROR = WIN32_ERROR(15150u32);
pub const ERROR_PRI_MERGE_ADD_FILE_FAILED: WIN32_ERROR = WIN32_ERROR(15151u32);
pub const ERROR_PRI_MERGE_WRITE_FILE_FAILED: WIN32_ERROR = WIN32_ERROR(15152u32);
pub const ERROR_PRI_MERGE_MULTIPLE_PACKAGE_FAMILIES_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(15153u32);
pub const ERROR_PRI_MERGE_MULTIPLE_MAIN_PACKAGES_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(15154u32);
pub const ERROR_PRI_MERGE_BUNDLE_PACKAGES_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(15155u32);
pub const ERROR_PRI_MERGE_MAIN_PACKAGE_REQUIRED: WIN32_ERROR = WIN32_ERROR(15156u32);
pub const ERROR_PRI_MERGE_RESOURCE_PACKAGE_REQUIRED: WIN32_ERROR = WIN32_ERROR(15157u32);
pub const ERROR_PRI_MERGE_INVALID_FILE_NAME: WIN32_ERROR = WIN32_ERROR(15158u32);
pub const ERROR_MRM_PACKAGE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15159u32);
pub const ERROR_MRM_MISSING_DEFAULT_LANGUAGE: WIN32_ERROR = WIN32_ERROR(15160u32);
pub const ERROR_MCA_INVALID_CAPABILITIES_STRING: WIN32_ERROR = WIN32_ERROR(15200u32);
pub const ERROR_MCA_INVALID_VCP_VERSION: WIN32_ERROR = WIN32_ERROR(15201u32);
pub const ERROR_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATION: WIN32_ERROR = WIN32_ERROR(15202u32);
pub const ERROR_MCA_MCCS_VERSION_MISMATCH: WIN32_ERROR = WIN32_ERROR(15203u32);
pub const ERROR_MCA_UNSUPPORTED_MCCS_VERSION: WIN32_ERROR = WIN32_ERROR(15204u32);
pub const ERROR_MCA_INTERNAL_ERROR: WIN32_ERROR = WIN32_ERROR(15205u32);
pub const ERROR_MCA_INVALID_TECHNOLOGY_TYPE_RETURNED: WIN32_ERROR = WIN32_ERROR(15206u32);
pub const ERROR_MCA_UNSUPPORTED_COLOR_TEMPERATURE: WIN32_ERROR = WIN32_ERROR(15207u32);
pub const ERROR_AMBIGUOUS_SYSTEM_DEVICE: WIN32_ERROR = WIN32_ERROR(15250u32);
pub const ERROR_SYSTEM_DEVICE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15299u32);
pub const ERROR_HASH_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(15300u32);
pub const ERROR_HASH_NOT_PRESENT: WIN32_ERROR = WIN32_ERROR(15301u32);
pub const ERROR_SECONDARY_IC_PROVIDER_NOT_REGISTERED: WIN32_ERROR = WIN32_ERROR(15321u32);
pub const ERROR_GPIO_CLIENT_INFORMATION_INVALID: WIN32_ERROR = WIN32_ERROR(15322u32);
pub const ERROR_GPIO_VERSION_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(15323u32);
pub const ERROR_GPIO_INVALID_REGISTRATION_PACKET: WIN32_ERROR = WIN32_ERROR(15324u32);
pub const ERROR_GPIO_OPERATION_DENIED: WIN32_ERROR = WIN32_ERROR(15325u32);
pub const ERROR_GPIO_INCOMPATIBLE_CONNECT_MODE: WIN32_ERROR = WIN32_ERROR(15326u32);
pub const ERROR_GPIO_INTERRUPT_ALREADY_UNMASKED: WIN32_ERROR = WIN32_ERROR(15327u32);
pub const ERROR_CANNOT_SWITCH_RUNLEVEL: WIN32_ERROR = WIN32_ERROR(15400u32);
pub const ERROR_INVALID_RUNLEVEL_SETTING: WIN32_ERROR = WIN32_ERROR(15401u32);
pub const ERROR_RUNLEVEL_SWITCH_TIMEOUT: WIN32_ERROR = WIN32_ERROR(15402u32);
pub const ERROR_RUNLEVEL_SWITCH_AGENT_TIMEOUT: WIN32_ERROR = WIN32_ERROR(15403u32);
pub const ERROR_RUNLEVEL_SWITCH_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(15404u32);
pub const ERROR_SERVICES_FAILED_AUTOSTART: WIN32_ERROR = WIN32_ERROR(15405u32);
pub const ERROR_COM_TASK_STOP_PENDING: WIN32_ERROR = WIN32_ERROR(15501u32);
pub const ERROR_INSTALL_OPEN_PACKAGE_FAILED: WIN32_ERROR = WIN32_ERROR(15600u32);
pub const ERROR_INSTALL_PACKAGE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(15601u32);
pub const ERROR_INSTALL_INVALID_PACKAGE: WIN32_ERROR = WIN32_ERROR(15602u32);
pub const ERROR_INSTALL_RESOLVE_DEPENDENCY_FAILED: WIN32_ERROR = WIN32_ERROR(15603u32);
pub const ERROR_INSTALL_OUT_OF_DISK_SPACE: WIN32_ERROR = WIN32_ERROR(15604u32);
pub const ERROR_INSTALL_NETWORK_FAILURE: WIN32_ERROR = WIN32_ERROR(15605u32);
pub const ERROR_INSTALL_REGISTRATION_FAILURE: WIN32_ERROR = WIN32_ERROR(15606u32);
pub const ERROR_INSTALL_DEREGISTRATION_FAILURE: WIN32_ERROR = WIN32_ERROR(15607u32);
pub const ERROR_INSTALL_CANCEL: WIN32_ERROR = WIN32_ERROR(15608u32);
pub const ERROR_INSTALL_FAILED: WIN32_ERROR = WIN32_ERROR(15609u32);
pub const ERROR_REMOVE_FAILED: WIN32_ERROR = WIN32_ERROR(15610u32);
pub const ERROR_PACKAGE_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(15611u32);
pub const ERROR_NEEDS_REMEDIATION: WIN32_ERROR = WIN32_ERROR(15612u32);
pub const ERROR_INSTALL_PREREQUISITE_FAILED: WIN32_ERROR = WIN32_ERROR(15613u32);
pub const ERROR_PACKAGE_REPOSITORY_CORRUPTED: WIN32_ERROR = WIN32_ERROR(15614u32);
pub const ERROR_INSTALL_POLICY_FAILURE: WIN32_ERROR = WIN32_ERROR(15615u32);
pub const ERROR_PACKAGE_UPDATING: WIN32_ERROR = WIN32_ERROR(15616u32);
pub const ERROR_DEPLOYMENT_BLOCKED_BY_POLICY: WIN32_ERROR = WIN32_ERROR(15617u32);
pub const ERROR_PACKAGES_IN_USE: WIN32_ERROR = WIN32_ERROR(15618u32);
pub const ERROR_RECOVERY_FILE_CORRUPT: WIN32_ERROR = WIN32_ERROR(15619u32);
pub const ERROR_INVALID_STAGED_SIGNATURE: WIN32_ERROR = WIN32_ERROR(15620u32);
pub const ERROR_DELETING_EXISTING_APPLICATIONDATA_STORE_FAILED: WIN32_ERROR = WIN32_ERROR(15621u32);
pub const ERROR_INSTALL_PACKAGE_DOWNGRADE: WIN32_ERROR = WIN32_ERROR(15622u32);
pub const ERROR_SYSTEM_NEEDS_REMEDIATION: WIN32_ERROR = WIN32_ERROR(15623u32);
pub const ERROR_APPX_INTEGRITY_FAILURE_CLR_NGEN: WIN32_ERROR = WIN32_ERROR(15624u32);
pub const ERROR_RESILIENCY_FILE_CORRUPT: WIN32_ERROR = WIN32_ERROR(15625u32);
pub const ERROR_INSTALL_FIREWALL_SERVICE_NOT_RUNNING: WIN32_ERROR = WIN32_ERROR(15626u32);
pub const ERROR_PACKAGE_MOVE_FAILED: WIN32_ERROR = WIN32_ERROR(15627u32);
pub const ERROR_INSTALL_VOLUME_NOT_EMPTY: WIN32_ERROR = WIN32_ERROR(15628u32);
pub const ERROR_INSTALL_VOLUME_OFFLINE: WIN32_ERROR = WIN32_ERROR(15629u32);
pub const ERROR_INSTALL_VOLUME_CORRUPT: WIN32_ERROR = WIN32_ERROR(15630u32);
pub const ERROR_NEEDS_REGISTRATION: WIN32_ERROR = WIN32_ERROR(15631u32);
pub const ERROR_INSTALL_WRONG_PROCESSOR_ARCHITECTURE: WIN32_ERROR = WIN32_ERROR(15632u32);
pub const ERROR_DEV_SIDELOAD_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(15633u32);
pub const ERROR_INSTALL_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE: WIN32_ERROR = WIN32_ERROR(15634u32);
pub const ERROR_PACKAGE_NOT_SUPPORTED_ON_FILESYSTEM: WIN32_ERROR = WIN32_ERROR(15635u32);
pub const ERROR_PACKAGE_MOVE_BLOCKED_BY_STREAMING: WIN32_ERROR = WIN32_ERROR(15636u32);
pub const ERROR_INSTALL_OPTIONAL_PACKAGE_APPLICATIONID_NOT_UNIQUE: WIN32_ERROR = WIN32_ERROR(15637u32);
pub const ERROR_PACKAGE_STAGING_ONHOLD: WIN32_ERROR = WIN32_ERROR(15638u32);
pub const ERROR_INSTALL_INVALID_RELATED_SET_UPDATE: WIN32_ERROR = WIN32_ERROR(15639u32);
pub const ERROR_INSTALL_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE_FULLTRUST_CAPABILITY: WIN32_ERROR = WIN32_ERROR(15640u32);
pub const ERROR_DEPLOYMENT_BLOCKED_BY_USER_LOG_OFF: WIN32_ERROR = WIN32_ERROR(15641u32);
pub const ERROR_PROVISION_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE_PROVISIONED: WIN32_ERROR = WIN32_ERROR(15642u32);
pub const ERROR_PACKAGES_REPUTATION_CHECK_FAILED: WIN32_ERROR = WIN32_ERROR(15643u32);
pub const ERROR_PACKAGES_REPUTATION_CHECK_TIMEDOUT: WIN32_ERROR = WIN32_ERROR(15644u32);
pub const ERROR_DEPLOYMENT_OPTION_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(15645u32);
pub const ERROR_APPINSTALLER_ACTIVATION_BLOCKED: WIN32_ERROR = WIN32_ERROR(15646u32);
pub const ERROR_REGISTRATION_FROM_REMOTE_DRIVE_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(15647u32);
pub const ERROR_APPX_RAW_DATA_WRITE_FAILED: WIN32_ERROR = WIN32_ERROR(15648u32);
pub const ERROR_DEPLOYMENT_BLOCKED_BY_VOLUME_POLICY_PACKAGE: WIN32_ERROR = WIN32_ERROR(15649u32);
pub const ERROR_DEPLOYMENT_BLOCKED_BY_VOLUME_POLICY_MACHINE: WIN32_ERROR = WIN32_ERROR(15650u32);
pub const ERROR_DEPLOYMENT_BLOCKED_BY_PROFILE_POLICY: WIN32_ERROR = WIN32_ERROR(15651u32);
pub const ERROR_DEPLOYMENT_FAILED_CONFLICTING_MUTABLE_PACKAGE_DIRECTORY: WIN32_ERROR = WIN32_ERROR(15652u32);
pub const ERROR_SINGLETON_RESOURCE_INSTALLED_IN_ACTIVE_USER: WIN32_ERROR = WIN32_ERROR(15653u32);
pub const ERROR_DIFFERENT_VERSION_OF_PACKAGED_SERVICE_INSTALLED: WIN32_ERROR = WIN32_ERROR(15654u32);
pub const ERROR_SERVICE_EXISTS_AS_NON_PACKAGED_SERVICE: WIN32_ERROR = WIN32_ERROR(15655u32);
pub const ERROR_PACKAGED_SERVICE_REQUIRES_ADMIN_PRIVILEGES: WIN32_ERROR = WIN32_ERROR(15656u32);
pub const ERROR_REDIRECTION_TO_DEFAULT_ACCOUNT_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(15657u32);
pub const ERROR_PACKAGE_LACKS_CAPABILITY_TO_DEPLOY_ON_HOST: WIN32_ERROR = WIN32_ERROR(15658u32);
pub const ERROR_UNSIGNED_PACKAGE_INVALID_CONTENT: WIN32_ERROR = WIN32_ERROR(15659u32);
pub const ERROR_UNSIGNED_PACKAGE_INVALID_PUBLISHER_NAMESPACE: WIN32_ERROR = WIN32_ERROR(15660u32);
pub const ERROR_SIGNED_PACKAGE_INVALID_PUBLISHER_NAMESPACE: WIN32_ERROR = WIN32_ERROR(15661u32);
pub const ERROR_PACKAGE_EXTERNAL_LOCATION_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(15662u32);
pub const ERROR_INSTALL_FULLTRUST_HOSTRUNTIME_REQUIRES_MAIN_PACKAGE_FULLTRUST_CAPABILITY: WIN32_ERROR = WIN32_ERROR(15663u32);
pub const ERROR_PACKAGE_LACKS_CAPABILITY_FOR_MANDATORY_STARTUPTASKS: WIN32_ERROR = WIN32_ERROR(15664u32);
pub const ERROR_INSTALL_RESOLVE_HOSTRUNTIME_DEPENDENCY_FAILED: WIN32_ERROR = WIN32_ERROR(15665u32);
pub const ERROR_MACHINE_SCOPE_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(15666u32);
pub const ERROR_CLASSIC_COMPAT_MODE_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(15667u32);
pub const ERROR_STAGEFROMUPDATEAGENT_PACKAGE_NOT_APPLICABLE: WIN32_ERROR = WIN32_ERROR(15668u32);
pub const ERROR_PACKAGE_NOT_REGISTERED_FOR_USER: WIN32_ERROR = WIN32_ERROR(15669u32);
pub const ERROR_STATE_LOAD_STORE_FAILED: WIN32_ERROR = WIN32_ERROR(15800u32);
pub const ERROR_STATE_GET_VERSION_FAILED: WIN32_ERROR = WIN32_ERROR(15801u32);
pub const ERROR_STATE_SET_VERSION_FAILED: WIN32_ERROR = WIN32_ERROR(15802u32);
pub const ERROR_STATE_STRUCTURED_RESET_FAILED: WIN32_ERROR = WIN32_ERROR(15803u32);
pub const ERROR_STATE_OPEN_CONTAINER_FAILED: WIN32_ERROR = WIN32_ERROR(15804u32);
pub const ERROR_STATE_CREATE_CONTAINER_FAILED: WIN32_ERROR = WIN32_ERROR(15805u32);
pub const ERROR_STATE_DELETE_CONTAINER_FAILED: WIN32_ERROR = WIN32_ERROR(15806u32);
pub const ERROR_STATE_READ_SETTING_FAILED: WIN32_ERROR = WIN32_ERROR(15807u32);
pub const ERROR_STATE_WRITE_SETTING_FAILED: WIN32_ERROR = WIN32_ERROR(15808u32);
pub const ERROR_STATE_DELETE_SETTING_FAILED: WIN32_ERROR = WIN32_ERROR(15809u32);
pub const ERROR_STATE_QUERY_SETTING_FAILED: WIN32_ERROR = WIN32_ERROR(15810u32);
pub const ERROR_STATE_READ_COMPOSITE_SETTING_FAILED: WIN32_ERROR = WIN32_ERROR(15811u32);
pub const ERROR_STATE_WRITE_COMPOSITE_SETTING_FAILED: WIN32_ERROR = WIN32_ERROR(15812u32);
pub const ERROR_STATE_ENUMERATE_CONTAINER_FAILED: WIN32_ERROR = WIN32_ERROR(15813u32);
pub const ERROR_STATE_ENUMERATE_SETTINGS_FAILED: WIN32_ERROR = WIN32_ERROR(15814u32);
pub const ERROR_STATE_COMPOSITE_SETTING_VALUE_SIZE_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(15815u32);
pub const ERROR_STATE_SETTING_VALUE_SIZE_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(15816u32);
pub const ERROR_STATE_SETTING_NAME_SIZE_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(15817u32);
pub const ERROR_STATE_CONTAINER_NAME_SIZE_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(15818u32);
pub const ERROR_API_UNAVAILABLE: WIN32_ERROR = WIN32_ERROR(15841u32);
pub const ERROR_NDIS_INTERFACE_CLOSING: WIN32_ERROR = WIN32_ERROR(2150891522u32);
pub const ERROR_NDIS_BAD_VERSION: WIN32_ERROR = WIN32_ERROR(2150891524u32);
pub const ERROR_NDIS_BAD_CHARACTERISTICS: WIN32_ERROR = WIN32_ERROR(2150891525u32);
pub const ERROR_NDIS_ADAPTER_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(2150891526u32);
pub const ERROR_NDIS_OPEN_FAILED: WIN32_ERROR = WIN32_ERROR(2150891527u32);
pub const ERROR_NDIS_DEVICE_FAILED: WIN32_ERROR = WIN32_ERROR(2150891528u32);
pub const ERROR_NDIS_MULTICAST_FULL: WIN32_ERROR = WIN32_ERROR(2150891529u32);
pub const ERROR_NDIS_MULTICAST_EXISTS: WIN32_ERROR = WIN32_ERROR(2150891530u32);
pub const ERROR_NDIS_MULTICAST_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(2150891531u32);
pub const ERROR_NDIS_REQUEST_ABORTED: WIN32_ERROR = WIN32_ERROR(2150891532u32);
pub const ERROR_NDIS_RESET_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(2150891533u32);
pub const ERROR_NDIS_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(2150891707u32);
pub const ERROR_NDIS_INVALID_PACKET: WIN32_ERROR = WIN32_ERROR(2150891535u32);
pub const ERROR_NDIS_ADAPTER_NOT_READY: WIN32_ERROR = WIN32_ERROR(2150891537u32);
pub const ERROR_NDIS_INVALID_LENGTH: WIN32_ERROR = WIN32_ERROR(2150891540u32);
pub const ERROR_NDIS_INVALID_DATA: WIN32_ERROR = WIN32_ERROR(2150891541u32);
pub const ERROR_NDIS_BUFFER_TOO_SHORT: WIN32_ERROR = WIN32_ERROR(2150891542u32);
pub const ERROR_NDIS_INVALID_OID: WIN32_ERROR = WIN32_ERROR(2150891543u32);
pub const ERROR_NDIS_ADAPTER_REMOVED: WIN32_ERROR = WIN32_ERROR(2150891544u32);
pub const ERROR_NDIS_UNSUPPORTED_MEDIA: WIN32_ERROR = WIN32_ERROR(2150891545u32);
pub const ERROR_NDIS_GROUP_ADDRESS_IN_USE: WIN32_ERROR = WIN32_ERROR(2150891546u32);
pub const ERROR_NDIS_FILE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(2150891547u32);
pub const ERROR_NDIS_ERROR_READING_FILE: WIN32_ERROR = WIN32_ERROR(2150891548u32);
pub const ERROR_NDIS_ALREADY_MAPPED: WIN32_ERROR = WIN32_ERROR(2150891549u32);
pub const ERROR_NDIS_RESOURCE_CONFLICT: WIN32_ERROR = WIN32_ERROR(2150891550u32);
pub const ERROR_NDIS_MEDIA_DISCONNECTED: WIN32_ERROR = WIN32_ERROR(2150891551u32);
pub const ERROR_NDIS_INVALID_ADDRESS: WIN32_ERROR = WIN32_ERROR(2150891554u32);
pub const ERROR_NDIS_INVALID_DEVICE_REQUEST: WIN32_ERROR = WIN32_ERROR(2150891536u32);
pub const ERROR_NDIS_PAUSED: WIN32_ERROR = WIN32_ERROR(2150891562u32);
pub const ERROR_NDIS_INTERFACE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(2150891563u32);
pub const ERROR_NDIS_UNSUPPORTED_REVISION: WIN32_ERROR = WIN32_ERROR(2150891564u32);
pub const ERROR_NDIS_INVALID_PORT: WIN32_ERROR = WIN32_ERROR(2150891565u32);
pub const ERROR_NDIS_INVALID_PORT_STATE: WIN32_ERROR = WIN32_ERROR(2150891566u32);
pub const ERROR_NDIS_LOW_POWER_STATE: WIN32_ERROR = WIN32_ERROR(2150891567u32);
pub const ERROR_NDIS_REINIT_REQUIRED: WIN32_ERROR = WIN32_ERROR(2150891568u32);
pub const ERROR_NDIS_NO_QUEUES: WIN32_ERROR = WIN32_ERROR(2150891569u32);
pub const ERROR_NDIS_DOT11_AUTO_CONFIG_ENABLED: WIN32_ERROR = WIN32_ERROR(2150899712u32);
pub const ERROR_NDIS_DOT11_MEDIA_IN_USE: WIN32_ERROR = WIN32_ERROR(2150899713u32);
pub const ERROR_NDIS_DOT11_POWER_STATE_INVALID: WIN32_ERROR = WIN32_ERROR(2150899714u32);
pub const ERROR_NDIS_PM_WOL_PATTERN_LIST_FULL: WIN32_ERROR = WIN32_ERROR(2150899715u32);
pub const ERROR_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL: WIN32_ERROR = WIN32_ERROR(2150899716u32);
pub const ERROR_NDIS_DOT11_AP_CHANNEL_CURRENTLY_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(2150899717u32);
pub const ERROR_NDIS_DOT11_AP_BAND_CURRENTLY_NOT_AVAILABLE: WIN32_ERROR = WIN32_ERROR(2150899718u32);
pub const ERROR_NDIS_DOT11_AP_CHANNEL_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(2150899719u32);
pub const ERROR_NDIS_DOT11_AP_BAND_NOT_ALLOWED: WIN32_ERROR = WIN32_ERROR(2150899720u32);
pub const ERROR_NDIS_INDICATION_REQUIRED: WIN32_ERROR = WIN32_ERROR(3407873u32);
pub const ERROR_NDIS_OFFLOAD_POLICY: WIN32_ERROR = WIN32_ERROR(3224637455u32);
pub const ERROR_NDIS_OFFLOAD_CONNECTION_REJECTED: WIN32_ERROR = WIN32_ERROR(3224637458u32);
pub const ERROR_NDIS_OFFLOAD_PATH_REJECTED: WIN32_ERROR = WIN32_ERROR(3224637459u32);
pub const ERROR_HV_INVALID_HYPERCALL_CODE: WIN32_ERROR = WIN32_ERROR(3224698882u32);
pub const ERROR_HV_INVALID_HYPERCALL_INPUT: WIN32_ERROR = WIN32_ERROR(3224698883u32);
pub const ERROR_HV_INVALID_ALIGNMENT: WIN32_ERROR = WIN32_ERROR(3224698884u32);
pub const ERROR_HV_INVALID_PARAMETER: WIN32_ERROR = WIN32_ERROR(3224698885u32);
pub const ERROR_HV_ACCESS_DENIED: WIN32_ERROR = WIN32_ERROR(3224698886u32);
pub const ERROR_HV_INVALID_PARTITION_STATE: WIN32_ERROR = WIN32_ERROR(3224698887u32);
pub const ERROR_HV_OPERATION_DENIED: WIN32_ERROR = WIN32_ERROR(3224698888u32);
pub const ERROR_HV_UNKNOWN_PROPERTY: WIN32_ERROR = WIN32_ERROR(3224698889u32);
pub const ERROR_HV_PROPERTY_VALUE_OUT_OF_RANGE: WIN32_ERROR = WIN32_ERROR(3224698890u32);
pub const ERROR_HV_INSUFFICIENT_MEMORY: WIN32_ERROR = WIN32_ERROR(3224698891u32);
pub const ERROR_HV_PARTITION_TOO_DEEP: WIN32_ERROR = WIN32_ERROR(3224698892u32);
pub const ERROR_HV_INVALID_PARTITION_ID: WIN32_ERROR = WIN32_ERROR(3224698893u32);
pub const ERROR_HV_INVALID_VP_INDEX: WIN32_ERROR = WIN32_ERROR(3224698894u32);
pub const ERROR_HV_INVALID_PORT_ID: WIN32_ERROR = WIN32_ERROR(3224698897u32);
pub const ERROR_HV_INVALID_CONNECTION_ID: WIN32_ERROR = WIN32_ERROR(3224698898u32);
pub const ERROR_HV_INSUFFICIENT_BUFFERS: WIN32_ERROR = WIN32_ERROR(3224698899u32);
pub const ERROR_HV_NOT_ACKNOWLEDGED: WIN32_ERROR = WIN32_ERROR(3224698900u32);
pub const ERROR_HV_INVALID_VP_STATE: WIN32_ERROR = WIN32_ERROR(3224698901u32);
pub const ERROR_HV_ACKNOWLEDGED: WIN32_ERROR = WIN32_ERROR(3224698902u32);
pub const ERROR_HV_INVALID_SAVE_RESTORE_STATE: WIN32_ERROR = WIN32_ERROR(3224698903u32);
pub const ERROR_HV_INVALID_SYNIC_STATE: WIN32_ERROR = WIN32_ERROR(3224698904u32);
pub const ERROR_HV_OBJECT_IN_USE: WIN32_ERROR = WIN32_ERROR(3224698905u32);
pub const ERROR_HV_INVALID_PROXIMITY_DOMAIN_INFO: WIN32_ERROR = WIN32_ERROR(3224698906u32);
pub const ERROR_HV_NO_DATA: WIN32_ERROR = WIN32_ERROR(3224698907u32);
pub const ERROR_HV_INACTIVE: WIN32_ERROR = WIN32_ERROR(3224698908u32);
pub const ERROR_HV_NO_RESOURCES: WIN32_ERROR = WIN32_ERROR(3224698909u32);
pub const ERROR_HV_FEATURE_UNAVAILABLE: WIN32_ERROR = WIN32_ERROR(3224698910u32);
pub const ERROR_HV_INSUFFICIENT_BUFFER: WIN32_ERROR = WIN32_ERROR(3224698931u32);
pub const ERROR_HV_INSUFFICIENT_DEVICE_DOMAINS: WIN32_ERROR = WIN32_ERROR(3224698936u32);
pub const ERROR_HV_CPUID_FEATURE_VALIDATION: WIN32_ERROR = WIN32_ERROR(3224698940u32);
pub const ERROR_HV_CPUID_XSAVE_FEATURE_VALIDATION: WIN32_ERROR = WIN32_ERROR(3224698941u32);
pub const ERROR_HV_PROCESSOR_STARTUP_TIMEOUT: WIN32_ERROR = WIN32_ERROR(3224698942u32);
pub const ERROR_HV_SMX_ENABLED: WIN32_ERROR = WIN32_ERROR(3224698943u32);
pub const ERROR_HV_INVALID_LP_INDEX: WIN32_ERROR = WIN32_ERROR(3224698945u32);
pub const ERROR_HV_INVALID_REGISTER_VALUE: WIN32_ERROR = WIN32_ERROR(3224698960u32);
pub const ERROR_HV_INVALID_VTL_STATE: WIN32_ERROR = WIN32_ERROR(3224698961u32);
pub const ERROR_HV_NX_NOT_DETECTED: WIN32_ERROR = WIN32_ERROR(3224698965u32);
pub const ERROR_HV_INVALID_DEVICE_ID: WIN32_ERROR = WIN32_ERROR(3224698967u32);
pub const ERROR_HV_INVALID_DEVICE_STATE: WIN32_ERROR = WIN32_ERROR(3224698968u32);
pub const ERROR_HV_PENDING_PAGE_REQUESTS: WIN32_ERROR = WIN32_ERROR(3473497u32);
pub const ERROR_HV_PAGE_REQUEST_INVALID: WIN32_ERROR = WIN32_ERROR(3224698976u32);
pub const ERROR_HV_INVALID_CPU_GROUP_ID: WIN32_ERROR = WIN32_ERROR(3224698991u32);
pub const ERROR_HV_INVALID_CPU_GROUP_STATE: WIN32_ERROR = WIN32_ERROR(3224698992u32);
pub const ERROR_HV_OPERATION_FAILED: WIN32_ERROR = WIN32_ERROR(3224698993u32);
pub const ERROR_HV_NOT_ALLOWED_WITH_NESTED_VIRT_ACTIVE: WIN32_ERROR = WIN32_ERROR(3224698994u32);
pub const ERROR_HV_INSUFFICIENT_ROOT_MEMORY: WIN32_ERROR = WIN32_ERROR(3224698995u32);
pub const ERROR_HV_EVENT_BUFFER_ALREADY_FREED: WIN32_ERROR = WIN32_ERROR(3224698996u32);
pub const ERROR_HV_INSUFFICIENT_CONTIGUOUS_MEMORY: WIN32_ERROR = WIN32_ERROR(3224698997u32);
pub const ERROR_HV_DEVICE_NOT_IN_DOMAIN: WIN32_ERROR = WIN32_ERROR(3224698998u32);
pub const ERROR_HV_NESTED_VM_EXIT: WIN32_ERROR = WIN32_ERROR(3224698999u32);
pub const ERROR_HV_MSR_ACCESS_FAILED: WIN32_ERROR = WIN32_ERROR(3224699008u32);
pub const ERROR_HV_NOT_PRESENT: WIN32_ERROR = WIN32_ERROR(3224702976u32);
pub const ERROR_VID_DUPLICATE_HANDLER: WIN32_ERROR = WIN32_ERROR(3224829953u32);
pub const ERROR_VID_TOO_MANY_HANDLERS: WIN32_ERROR = WIN32_ERROR(3224829954u32);
pub const ERROR_VID_QUEUE_FULL: WIN32_ERROR = WIN32_ERROR(3224829955u32);
pub const ERROR_VID_HANDLER_NOT_PRESENT: WIN32_ERROR = WIN32_ERROR(3224829956u32);
pub const ERROR_VID_INVALID_OBJECT_NAME: WIN32_ERROR = WIN32_ERROR(3224829957u32);
pub const ERROR_VID_PARTITION_NAME_TOO_LONG: WIN32_ERROR = WIN32_ERROR(3224829958u32);
pub const ERROR_VID_MESSAGE_QUEUE_NAME_TOO_LONG: WIN32_ERROR = WIN32_ERROR(3224829959u32);
pub const ERROR_VID_PARTITION_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(3224829960u32);
pub const ERROR_VID_PARTITION_DOES_NOT_EXIST: WIN32_ERROR = WIN32_ERROR(3224829961u32);
pub const ERROR_VID_PARTITION_NAME_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(3224829962u32);
pub const ERROR_VID_MESSAGE_QUEUE_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(3224829963u32);
pub const ERROR_VID_EXCEEDED_MBP_ENTRY_MAP_LIMIT: WIN32_ERROR = WIN32_ERROR(3224829964u32);
pub const ERROR_VID_MB_STILL_REFERENCED: WIN32_ERROR = WIN32_ERROR(3224829965u32);
pub const ERROR_VID_CHILD_GPA_PAGE_SET_CORRUPTED: WIN32_ERROR = WIN32_ERROR(3224829966u32);
pub const ERROR_VID_INVALID_NUMA_SETTINGS: WIN32_ERROR = WIN32_ERROR(3224829967u32);
pub const ERROR_VID_INVALID_NUMA_NODE_INDEX: WIN32_ERROR = WIN32_ERROR(3224829968u32);
pub const ERROR_VID_NOTIFICATION_QUEUE_ALREADY_ASSOCIATED: WIN32_ERROR = WIN32_ERROR(3224829969u32);
pub const ERROR_VID_INVALID_MEMORY_BLOCK_HANDLE: WIN32_ERROR = WIN32_ERROR(3224829970u32);
pub const ERROR_VID_PAGE_RANGE_OVERFLOW: WIN32_ERROR = WIN32_ERROR(3224829971u32);
pub const ERROR_VID_INVALID_MESSAGE_QUEUE_HANDLE: WIN32_ERROR = WIN32_ERROR(3224829972u32);
pub const ERROR_VID_INVALID_GPA_RANGE_HANDLE: WIN32_ERROR = WIN32_ERROR(3224829973u32);
pub const ERROR_VID_NO_MEMORY_BLOCK_NOTIFICATION_QUEUE: WIN32_ERROR = WIN32_ERROR(3224829974u32);
pub const ERROR_VID_MEMORY_BLOCK_LOCK_COUNT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(3224829975u32);
pub const ERROR_VID_INVALID_PPM_HANDLE: WIN32_ERROR = WIN32_ERROR(3224829976u32);
pub const ERROR_VID_MBPS_ARE_LOCKED: WIN32_ERROR = WIN32_ERROR(3224829977u32);
pub const ERROR_VID_MESSAGE_QUEUE_CLOSED: WIN32_ERROR = WIN32_ERROR(3224829978u32);
pub const ERROR_VID_VIRTUAL_PROCESSOR_LIMIT_EXCEEDED: WIN32_ERROR = WIN32_ERROR(3224829979u32);
pub const ERROR_VID_STOP_PENDING: WIN32_ERROR = WIN32_ERROR(3224829980u32);
pub const ERROR_VID_INVALID_PROCESSOR_STATE: WIN32_ERROR = WIN32_ERROR(3224829981u32);
pub const ERROR_VID_EXCEEDED_KM_CONTEXT_COUNT_LIMIT: WIN32_ERROR = WIN32_ERROR(3224829982u32);
pub const ERROR_VID_KM_INTERFACE_ALREADY_INITIALIZED: WIN32_ERROR = WIN32_ERROR(3224829983u32);
pub const ERROR_VID_MB_PROPERTY_ALREADY_SET_RESET: WIN32_ERROR = WIN32_ERROR(3224829984u32);
pub const ERROR_VID_MMIO_RANGE_DESTROYED: WIN32_ERROR = WIN32_ERROR(3224829985u32);
pub const ERROR_VID_INVALID_CHILD_GPA_PAGE_SET: WIN32_ERROR = WIN32_ERROR(3224829986u32);
pub const ERROR_VID_RESERVE_PAGE_SET_IS_BEING_USED: WIN32_ERROR = WIN32_ERROR(3224829987u32);
pub const ERROR_VID_RESERVE_PAGE_SET_TOO_SMALL: WIN32_ERROR = WIN32_ERROR(3224829988u32);
pub const ERROR_VID_MBP_ALREADY_LOCKED_USING_RESERVED_PAGE: WIN32_ERROR = WIN32_ERROR(3224829989u32);
pub const ERROR_VID_MBP_COUNT_EXCEEDED_LIMIT: WIN32_ERROR = WIN32_ERROR(3224829990u32);
pub const ERROR_VID_SAVED_STATE_CORRUPT: WIN32_ERROR = WIN32_ERROR(3224829991u32);
pub const ERROR_VID_SAVED_STATE_UNRECOGNIZED_ITEM: WIN32_ERROR = WIN32_ERROR(3224829992u32);
pub const ERROR_VID_SAVED_STATE_INCOMPATIBLE: WIN32_ERROR = WIN32_ERROR(3224829993u32);
pub const ERROR_VID_VTL_ACCESS_DENIED: WIN32_ERROR = WIN32_ERROR(3224829994u32);
pub const ERROR_VMCOMPUTE_TERMINATED_DURING_START: WIN32_ERROR = WIN32_ERROR(3224830208u32);
pub const ERROR_VMCOMPUTE_IMAGE_MISMATCH: WIN32_ERROR = WIN32_ERROR(3224830209u32);
pub const ERROR_VMCOMPUTE_HYPERV_NOT_INSTALLED: WIN32_ERROR = WIN32_ERROR(3224830210u32);
pub const ERROR_VMCOMPUTE_OPERATION_PENDING: WIN32_ERROR = WIN32_ERROR(3224830211u32);
pub const ERROR_VMCOMPUTE_TOO_MANY_NOTIFICATIONS: WIN32_ERROR = WIN32_ERROR(3224830212u32);
pub const ERROR_VMCOMPUTE_INVALID_STATE: WIN32_ERROR = WIN32_ERROR(3224830213u32);
pub const ERROR_VMCOMPUTE_UNEXPECTED_EXIT: WIN32_ERROR = WIN32_ERROR(3224830214u32);
pub const ERROR_VMCOMPUTE_TERMINATED: WIN32_ERROR = WIN32_ERROR(3224830215u32);
pub const ERROR_VMCOMPUTE_CONNECT_FAILED: WIN32_ERROR = WIN32_ERROR(3224830216u32);
pub const ERROR_VMCOMPUTE_TIMEOUT: WIN32_ERROR = WIN32_ERROR(3224830217u32);
pub const ERROR_VMCOMPUTE_CONNECTION_CLOSED: WIN32_ERROR = WIN32_ERROR(3224830218u32);
pub const ERROR_VMCOMPUTE_UNKNOWN_MESSAGE: WIN32_ERROR = WIN32_ERROR(3224830219u32);
pub const ERROR_VMCOMPUTE_UNSUPPORTED_PROTOCOL_VERSION: WIN32_ERROR = WIN32_ERROR(3224830220u32);
pub const ERROR_VMCOMPUTE_INVALID_JSON: WIN32_ERROR = WIN32_ERROR(3224830221u32);
pub const ERROR_VMCOMPUTE_SYSTEM_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(3224830222u32);
pub const ERROR_VMCOMPUTE_SYSTEM_ALREADY_EXISTS: WIN32_ERROR = WIN32_ERROR(3224830223u32);
pub const ERROR_VMCOMPUTE_SYSTEM_ALREADY_STOPPED: WIN32_ERROR = WIN32_ERROR(3224830224u32);
pub const ERROR_VMCOMPUTE_PROTOCOL_ERROR: WIN32_ERROR = WIN32_ERROR(3224830225u32);
pub const ERROR_VMCOMPUTE_INVALID_LAYER: WIN32_ERROR = WIN32_ERROR(3224830226u32);
pub const ERROR_VMCOMPUTE_WINDOWS_INSIDER_REQUIRED: WIN32_ERROR = WIN32_ERROR(3224830227u32);
pub const ERROR_VNET_VIRTUAL_SWITCH_NAME_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(3224830464u32);
pub const ERROR_VID_REMOTE_NODE_PARENT_GPA_PAGES_USED: WIN32_ERROR = WIN32_ERROR(2151088129u32);
pub const ERROR_VSMB_SAVED_STATE_FILE_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(3224830976u32);
pub const ERROR_VSMB_SAVED_STATE_CORRUPT: WIN32_ERROR = WIN32_ERROR(3224830977u32);
pub const ERROR_VOLMGR_INCOMPLETE_REGENERATION: WIN32_ERROR = WIN32_ERROR(2151153665u32);
pub const ERROR_VOLMGR_INCOMPLETE_DISK_MIGRATION: WIN32_ERROR = WIN32_ERROR(2151153666u32);
pub const ERROR_VOLMGR_DATABASE_FULL: WIN32_ERROR = WIN32_ERROR(3224895489u32);
pub const ERROR_VOLMGR_DISK_CONFIGURATION_CORRUPTED: WIN32_ERROR = WIN32_ERROR(3224895490u32);
pub const ERROR_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNC: WIN32_ERROR = WIN32_ERROR(3224895491u32);
pub const ERROR_VOLMGR_PACK_CONFIG_UPDATE_FAILED: WIN32_ERROR = WIN32_ERROR(3224895492u32);
pub const ERROR_VOLMGR_DISK_CONTAINS_NON_SIMPLE_VOLUME: WIN32_ERROR = WIN32_ERROR(3224895493u32);
pub const ERROR_VOLMGR_DISK_DUPLICATE: WIN32_ERROR = WIN32_ERROR(3224895494u32);
pub const ERROR_VOLMGR_DISK_DYNAMIC: WIN32_ERROR = WIN32_ERROR(3224895495u32);
pub const ERROR_VOLMGR_DISK_ID_INVALID: WIN32_ERROR = WIN32_ERROR(3224895496u32);
pub const ERROR_VOLMGR_DISK_INVALID: WIN32_ERROR = WIN32_ERROR(3224895497u32);
pub const ERROR_VOLMGR_DISK_LAST_VOTER: WIN32_ERROR = WIN32_ERROR(3224895498u32);
pub const ERROR_VOLMGR_DISK_LAYOUT_INVALID: WIN32_ERROR = WIN32_ERROR(3224895499u32);
pub const ERROR_VOLMGR_DISK_LAYOUT_NON_BASIC_BETWEEN_BASIC_PARTITIONS: WIN32_ERROR = WIN32_ERROR(3224895500u32);
pub const ERROR_VOLMGR_DISK_LAYOUT_NOT_CYLINDER_ALIGNED: WIN32_ERROR = WIN32_ERROR(3224895501u32);
pub const ERROR_VOLMGR_DISK_LAYOUT_PARTITIONS_TOO_SMALL: WIN32_ERROR = WIN32_ERROR(3224895502u32);
pub const ERROR_VOLMGR_DISK_LAYOUT_PRIMARY_BETWEEN_LOGICAL_PARTITIONS: WIN32_ERROR = WIN32_ERROR(3224895503u32);
pub const ERROR_VOLMGR_DISK_LAYOUT_TOO_MANY_PARTITIONS: WIN32_ERROR = WIN32_ERROR(3224895504u32);
pub const ERROR_VOLMGR_DISK_MISSING: WIN32_ERROR = WIN32_ERROR(3224895505u32);
pub const ERROR_VOLMGR_DISK_NOT_EMPTY: WIN32_ERROR = WIN32_ERROR(3224895506u32);
pub const ERROR_VOLMGR_DISK_NOT_ENOUGH_SPACE: WIN32_ERROR = WIN32_ERROR(3224895507u32);
pub const ERROR_VOLMGR_DISK_REVECTORING_FAILED: WIN32_ERROR = WIN32_ERROR(3224895508u32);
pub const ERROR_VOLMGR_DISK_SECTOR_SIZE_INVALID: WIN32_ERROR = WIN32_ERROR(3224895509u32);
pub const ERROR_VOLMGR_DISK_SET_NOT_CONTAINED: WIN32_ERROR = WIN32_ERROR(3224895510u32);
pub const ERROR_VOLMGR_DISK_USED_BY_MULTIPLE_MEMBERS: WIN32_ERROR = WIN32_ERROR(3224895511u32);
pub const ERROR_VOLMGR_DISK_USED_BY_MULTIPLE_PLEXES: WIN32_ERROR = WIN32_ERROR(3224895512u32);
pub const ERROR_VOLMGR_DYNAMIC_DISK_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(3224895513u32);
pub const ERROR_VOLMGR_EXTENT_ALREADY_USED: WIN32_ERROR = WIN32_ERROR(3224895514u32);
pub const ERROR_VOLMGR_EXTENT_NOT_CONTIGUOUS: WIN32_ERROR = WIN32_ERROR(3224895515u32);
pub const ERROR_VOLMGR_EXTENT_NOT_IN_PUBLIC_REGION: WIN32_ERROR = WIN32_ERROR(3224895516u32);
pub const ERROR_VOLMGR_EXTENT_NOT_SECTOR_ALIGNED: WIN32_ERROR = WIN32_ERROR(3224895517u32);
pub const ERROR_VOLMGR_EXTENT_OVERLAPS_EBR_PARTITION: WIN32_ERROR = WIN32_ERROR(3224895518u32);
pub const ERROR_VOLMGR_EXTENT_VOLUME_LENGTHS_DO_NOT_MATCH: WIN32_ERROR = WIN32_ERROR(3224895519u32);
pub const ERROR_VOLMGR_FAULT_TOLERANT_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(3224895520u32);
pub const ERROR_VOLMGR_INTERLEAVE_LENGTH_INVALID: WIN32_ERROR = WIN32_ERROR(3224895521u32);
pub const ERROR_VOLMGR_MAXIMUM_REGISTERED_USERS: WIN32_ERROR = WIN32_ERROR(3224895522u32);
pub const ERROR_VOLMGR_MEMBER_IN_SYNC: WIN32_ERROR = WIN32_ERROR(3224895523u32);
pub const ERROR_VOLMGR_MEMBER_INDEX_DUPLICATE: WIN32_ERROR = WIN32_ERROR(3224895524u32);
pub const ERROR_VOLMGR_MEMBER_INDEX_INVALID: WIN32_ERROR = WIN32_ERROR(3224895525u32);
pub const ERROR_VOLMGR_MEMBER_MISSING: WIN32_ERROR = WIN32_ERROR(3224895526u32);
pub const ERROR_VOLMGR_MEMBER_NOT_DETACHED: WIN32_ERROR = WIN32_ERROR(3224895527u32);
pub const ERROR_VOLMGR_MEMBER_REGENERATING: WIN32_ERROR = WIN32_ERROR(3224895528u32);
pub const ERROR_VOLMGR_ALL_DISKS_FAILED: WIN32_ERROR = WIN32_ERROR(3224895529u32);
pub const ERROR_VOLMGR_NO_REGISTERED_USERS: WIN32_ERROR = WIN32_ERROR(3224895530u32);
pub const ERROR_VOLMGR_NO_SUCH_USER: WIN32_ERROR = WIN32_ERROR(3224895531u32);
pub const ERROR_VOLMGR_NOTIFICATION_RESET: WIN32_ERROR = WIN32_ERROR(3224895532u32);
pub const ERROR_VOLMGR_NUMBER_OF_MEMBERS_INVALID: WIN32_ERROR = WIN32_ERROR(3224895533u32);
pub const ERROR_VOLMGR_NUMBER_OF_PLEXES_INVALID: WIN32_ERROR = WIN32_ERROR(3224895534u32);
pub const ERROR_VOLMGR_PACK_DUPLICATE: WIN32_ERROR = WIN32_ERROR(3224895535u32);
pub const ERROR_VOLMGR_PACK_ID_INVALID: WIN32_ERROR = WIN32_ERROR(3224895536u32);
pub const ERROR_VOLMGR_PACK_INVALID: WIN32_ERROR = WIN32_ERROR(3224895537u32);
pub const ERROR_VOLMGR_PACK_NAME_INVALID: WIN32_ERROR = WIN32_ERROR(3224895538u32);
pub const ERROR_VOLMGR_PACK_OFFLINE: WIN32_ERROR = WIN32_ERROR(3224895539u32);
pub const ERROR_VOLMGR_PACK_HAS_QUORUM: WIN32_ERROR = WIN32_ERROR(3224895540u32);
pub const ERROR_VOLMGR_PACK_WITHOUT_QUORUM: WIN32_ERROR = WIN32_ERROR(3224895541u32);
pub const ERROR_VOLMGR_PARTITION_STYLE_INVALID: WIN32_ERROR = WIN32_ERROR(3224895542u32);
pub const ERROR_VOLMGR_PARTITION_UPDATE_FAILED: WIN32_ERROR = WIN32_ERROR(3224895543u32);
pub const ERROR_VOLMGR_PLEX_IN_SYNC: WIN32_ERROR = WIN32_ERROR(3224895544u32);
pub const ERROR_VOLMGR_PLEX_INDEX_DUPLICATE: WIN32_ERROR = WIN32_ERROR(3224895545u32);
pub const ERROR_VOLMGR_PLEX_INDEX_INVALID: WIN32_ERROR = WIN32_ERROR(3224895546u32);
pub const ERROR_VOLMGR_PLEX_LAST_ACTIVE: WIN32_ERROR = WIN32_ERROR(3224895547u32);
pub const ERROR_VOLMGR_PLEX_MISSING: WIN32_ERROR = WIN32_ERROR(3224895548u32);
pub const ERROR_VOLMGR_PLEX_REGENERATING: WIN32_ERROR = WIN32_ERROR(3224895549u32);
pub const ERROR_VOLMGR_PLEX_TYPE_INVALID: WIN32_ERROR = WIN32_ERROR(3224895550u32);
pub const ERROR_VOLMGR_PLEX_NOT_RAID5: WIN32_ERROR = WIN32_ERROR(3224895551u32);
pub const ERROR_VOLMGR_PLEX_NOT_SIMPLE: WIN32_ERROR = WIN32_ERROR(3224895552u32);
pub const ERROR_VOLMGR_STRUCTURE_SIZE_INVALID: WIN32_ERROR = WIN32_ERROR(3224895553u32);
pub const ERROR_VOLMGR_TOO_MANY_NOTIFICATION_REQUESTS: WIN32_ERROR = WIN32_ERROR(3224895554u32);
pub const ERROR_VOLMGR_TRANSACTION_IN_PROGRESS: WIN32_ERROR = WIN32_ERROR(3224895555u32);
pub const ERROR_VOLMGR_UNEXPECTED_DISK_LAYOUT_CHANGE: WIN32_ERROR = WIN32_ERROR(3224895556u32);
pub const ERROR_VOLMGR_VOLUME_CONTAINS_MISSING_DISK: WIN32_ERROR = WIN32_ERROR(3224895557u32);
pub const ERROR_VOLMGR_VOLUME_ID_INVALID: WIN32_ERROR = WIN32_ERROR(3224895558u32);
pub const ERROR_VOLMGR_VOLUME_LENGTH_INVALID: WIN32_ERROR = WIN32_ERROR(3224895559u32);
pub const ERROR_VOLMGR_VOLUME_LENGTH_NOT_SECTOR_SIZE_MULTIPLE: WIN32_ERROR = WIN32_ERROR(3224895560u32);
pub const ERROR_VOLMGR_VOLUME_NOT_MIRRORED: WIN32_ERROR = WIN32_ERROR(3224895561u32);
pub const ERROR_VOLMGR_VOLUME_NOT_RETAINED: WIN32_ERROR = WIN32_ERROR(3224895562u32);
pub const ERROR_VOLMGR_VOLUME_OFFLINE: WIN32_ERROR = WIN32_ERROR(3224895563u32);
pub const ERROR_VOLMGR_VOLUME_RETAINED: WIN32_ERROR = WIN32_ERROR(3224895564u32);
pub const ERROR_VOLMGR_NUMBER_OF_EXTENTS_INVALID: WIN32_ERROR = WIN32_ERROR(3224895565u32);
pub const ERROR_VOLMGR_DIFFERENT_SECTOR_SIZE: WIN32_ERROR = WIN32_ERROR(3224895566u32);
pub const ERROR_VOLMGR_BAD_BOOT_DISK: WIN32_ERROR = WIN32_ERROR(3224895567u32);
pub const ERROR_VOLMGR_PACK_CONFIG_OFFLINE: WIN32_ERROR = WIN32_ERROR(3224895568u32);
pub const ERROR_VOLMGR_PACK_CONFIG_ONLINE: WIN32_ERROR = WIN32_ERROR(3224895569u32);
pub const ERROR_VOLMGR_NOT_PRIMARY_PACK: WIN32_ERROR = WIN32_ERROR(3224895570u32);
pub const ERROR_VOLMGR_PACK_LOG_UPDATE_FAILED: WIN32_ERROR = WIN32_ERROR(3224895571u32);
pub const ERROR_VOLMGR_NUMBER_OF_DISKS_IN_PLEX_INVALID: WIN32_ERROR = WIN32_ERROR(3224895572u32);
pub const ERROR_VOLMGR_NUMBER_OF_DISKS_IN_MEMBER_INVALID: WIN32_ERROR = WIN32_ERROR(3224895573u32);
pub const ERROR_VOLMGR_VOLUME_MIRRORED: WIN32_ERROR = WIN32_ERROR(3224895574u32);
pub const ERROR_VOLMGR_PLEX_NOT_SIMPLE_SPANNED: WIN32_ERROR = WIN32_ERROR(3224895575u32);
pub const ERROR_VOLMGR_NO_VALID_LOG_COPIES: WIN32_ERROR = WIN32_ERROR(3224895576u32);
pub const ERROR_VOLMGR_PRIMARY_PACK_PRESENT: WIN32_ERROR = WIN32_ERROR(3224895577u32);
pub const ERROR_VOLMGR_NUMBER_OF_DISKS_INVALID: WIN32_ERROR = WIN32_ERROR(3224895578u32);
pub const ERROR_VOLMGR_MIRROR_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(3224895579u32);
pub const ERROR_VOLMGR_RAID5_NOT_SUPPORTED: WIN32_ERROR = WIN32_ERROR(3224895580u32);
pub const ERROR_BCD_NOT_ALL_ENTRIES_IMPORTED: WIN32_ERROR = WIN32_ERROR(2151219201u32);
pub const ERROR_BCD_TOO_MANY_ELEMENTS: WIN32_ERROR = WIN32_ERROR(3224961026u32);
pub const ERROR_BCD_NOT_ALL_ENTRIES_SYNCHRONIZED: WIN32_ERROR = WIN32_ERROR(2151219203u32);
pub const ERROR_VHD_DRIVE_FOOTER_MISSING: WIN32_ERROR = WIN32_ERROR(3225026561u32);
pub const ERROR_VHD_DRIVE_FOOTER_CHECKSUM_MISMATCH: WIN32_ERROR = WIN32_ERROR(3225026562u32);
pub const ERROR_VHD_DRIVE_FOOTER_CORRUPT: WIN32_ERROR = WIN32_ERROR(3225026563u32);
pub const ERROR_VHD_FORMAT_UNKNOWN: WIN32_ERROR = WIN32_ERROR(3225026564u32);
pub const ERROR_VHD_FORMAT_UNSUPPORTED_VERSION: WIN32_ERROR = WIN32_ERROR(3225026565u32);
pub const ERROR_VHD_SPARSE_HEADER_CHECKSUM_MISMATCH: WIN32_ERROR = WIN32_ERROR(3225026566u32);
pub const ERROR_VHD_SPARSE_HEADER_UNSUPPORTED_VERSION: WIN32_ERROR = WIN32_ERROR(3225026567u32);
pub const ERROR_VHD_SPARSE_HEADER_CORRUPT: WIN32_ERROR = WIN32_ERROR(3225026568u32);
pub const ERROR_VHD_BLOCK_ALLOCATION_FAILURE: WIN32_ERROR = WIN32_ERROR(3225026569u32);
pub const ERROR_VHD_BLOCK_ALLOCATION_TABLE_CORRUPT: WIN32_ERROR = WIN32_ERROR(3225026570u32);
pub const ERROR_VHD_INVALID_BLOCK_SIZE: WIN32_ERROR = WIN32_ERROR(3225026571u32);
pub const ERROR_VHD_BITMAP_MISMATCH: WIN32_ERROR = WIN32_ERROR(3225026572u32);
pub const ERROR_VHD_PARENT_VHD_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(3225026573u32);
pub const ERROR_VHD_CHILD_PARENT_ID_MISMATCH: WIN32_ERROR = WIN32_ERROR(3225026574u32);
pub const ERROR_VHD_CHILD_PARENT_TIMESTAMP_MISMATCH: WIN32_ERROR = WIN32_ERROR(3225026575u32);
pub const ERROR_VHD_METADATA_READ_FAILURE: WIN32_ERROR = WIN32_ERROR(3225026576u32);
pub const ERROR_VHD_METADATA_WRITE_FAILURE: WIN32_ERROR = WIN32_ERROR(3225026577u32);
pub const ERROR_VHD_INVALID_SIZE: WIN32_ERROR = WIN32_ERROR(3225026578u32);
pub const ERROR_VHD_INVALID_FILE_SIZE: WIN32_ERROR = WIN32_ERROR(3225026579u32);
pub const ERROR_VIRTDISK_PROVIDER_NOT_FOUND: WIN32_ERROR = WIN32_ERROR(3225026580u32);
pub const ERROR_VIRTDISK_NOT_VIRTUAL_DISK: WIN32_ERROR = WIN32_ERROR(3225026581u32);
pub const ERROR_VHD_PARENT_VHD_ACCESS_DENIED: WIN32_ERROR = WIN32_ERROR(3225026582u32);
pub const ERROR_VHD_CHILD_PARENT_SIZE_MISMATCH: WIN32_ERROR = WIN32_ERROR(3225026583u32);
pub const ERROR_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED: WIN32_ERROR = WIN32_ERROR(3225026584u32);
pub const ERROR_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT: WIN32_ERROR = WIN32_ERROR(3225026585u32);
pub const ERROR_VIRTUAL_DISK_LIMITATION: WIN32_ERROR = WIN32_ERROR(3225026586u32);
pub const ERROR_VHD_INVALID_TYPE: WIN32_ERROR = WIN32_ERROR(3225026587u32);
pub const ERROR_VHD_INVALID_STATE: WIN32_ERROR = WIN32_ERROR(3225026588u32);
pub const ERROR_VIRTDISK_UNSUPPORTED_DISK_SECTOR_SIZE: WIN32_ERROR = WIN32_ERROR(3225026589u32);
pub const ERROR_VIRTDISK_DISK_ALREADY_OWNED: WIN32_ERROR = WIN32_ERROR(3225026590u32);
pub const ERROR_VIRTDISK_DISK_ONLINE_AND_WRITABLE: WIN32_ERROR = WIN32_ERROR(3225026591u32);
pub const ERROR_CTLOG_TRACKING_NOT_INITIALIZED: WIN32_ERROR = WIN32_ERROR(3225026592u32);
pub const ERROR_CTLOG_LOGFILE_SIZE_EXCEEDED_MAXSIZE: WIN32_ERROR = WIN32_ERROR(3225026593u32);
pub const ERROR_CTLOG_VHD_CHANGED_OFFLINE: WIN32_ERROR = WIN32_ERROR(3225026594u32);
pub const ERROR_CTLOG_INVALID_TRACKING_STATE: WIN32_ERROR = WIN32_ERROR(3225026595u32);
pub const ERROR_CTLOG_INCONSISTENT_TRACKING_FILE: WIN32_ERROR = WIN32_ERROR(3225026596u32);
pub const ERROR_VHD_RESIZE_WOULD_TRUNCATE_DATA: WIN32_ERROR = WIN32_ERROR(3225026597u32);
pub const ERROR_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZE: WIN32_ERROR = WIN32_ERROR(3225026598u32);
pub const ERROR_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZE: WIN32_ERROR = WIN32_ERROR(3225026599u32);
pub const ERROR_VHD_METADATA_FULL: WIN32_ERROR = WIN32_ERROR(3225026600u32);
pub const ERROR_VHD_INVALID_CHANGE_TRACKING_ID: WIN32_ERROR = WIN32_ERROR(3225026601u32);
pub const ERROR_VHD_CHANGE_TRACKING_DISABLED: WIN32_ERROR = WIN32_ERROR(3225026602u32);
pub const ERROR_VHD_MISSING_CHANGE_TRACKING_INFORMATION: WIN32_ERROR = WIN32_ERROR(3225026608u32);
pub const ERROR_QUERY_STORAGE_ERROR: WIN32_ERROR = WIN32_ERROR(2151284737u32);
impl ::core::convert::From<u32> for WIN32_ERROR {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for WIN32_ERROR {
type Abi = Self;
}
impl ::core::ops::BitOr for WIN32_ERROR {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for WIN32_ERROR {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for WIN32_ERROR {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for WIN32_ERROR {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for WIN32_ERROR {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
impl ::core::convert::From<WIN32_ERROR> for ::windows::core::HRESULT {
fn from(value: WIN32_ERROR) -> Self {
Self(if value.0 as i32 <= 0 { value.0 } else { (value.0 & 0x0000_FFFF) | (7 << 16) | 0x8000_0000 })
}
}
pub const WINCODEC_ERR_ALREADYLOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292403i32 as _);
pub const WINCODEC_ERR_BADHEADER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292319i32 as _);
pub const WINCODEC_ERR_BADIMAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292320i32 as _);
pub const WINCODEC_ERR_BADMETADATAHEADER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292317i32 as _);
pub const WINCODEC_ERR_BADSTREAMDATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292304i32 as _);
pub const WINCODEC_ERR_CODECNOTHUMBNAIL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292348i32 as _);
pub const WINCODEC_ERR_CODECPRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292349i32 as _);
pub const WINCODEC_ERR_CODECTOOMANYSCANLINES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292346i32 as _);
pub const WINCODEC_ERR_COMPONENTINITIALIZEFAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292277i32 as _);
pub const WINCODEC_ERR_COMPONENTNOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292336i32 as _);
pub const WINCODEC_ERR_DUPLICATEMETADATAPRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292275i32 as _);
pub const WINCODEC_ERR_FRAMEMISSING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292318i32 as _);
pub const WINCODEC_ERR_IMAGESIZEOUTOFRANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292335i32 as _);
pub const WINCODEC_ERR_INSUFFICIENTBUFFER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292276i32 as _);
pub const WINCODEC_ERR_INTERNALERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292344i32 as _);
pub const WINCODEC_ERR_INVALIDJPEGSCANINDEX: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292266i32 as _);
pub const WINCODEC_ERR_INVALIDPROGRESSIVELEVEL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292267i32 as _);
pub const WINCODEC_ERR_INVALIDQUERYCHARACTER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292269i32 as _);
pub const WINCODEC_ERR_INVALIDQUERYREQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292272i32 as _);
pub const WINCODEC_ERR_INVALIDREGISTRATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292278i32 as _);
pub const WINCODEC_ERR_NOTINITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292404i32 as _);
pub const WINCODEC_ERR_PALETTEUNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292347i32 as _);
pub const WINCODEC_ERR_PROPERTYNOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292352i32 as _);
pub const WINCODEC_ERR_PROPERTYNOTSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292351i32 as _);
pub const WINCODEC_ERR_PROPERTYSIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292350i32 as _);
pub const WINCODEC_ERR_PROPERTYUNEXPECTEDTYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292274i32 as _);
pub const WINCODEC_ERR_REQUESTONLYVALIDATMETADATAROOT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292270i32 as _);
pub const WINCODEC_ERR_SOURCERECTDOESNOTMATCHDIMENSIONS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292343i32 as _);
pub const WINCODEC_ERR_STREAMNOTAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292301i32 as _);
pub const WINCODEC_ERR_STREAMREAD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292302i32 as _);
pub const WINCODEC_ERR_STREAMWRITE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292303i32 as _);
pub const WINCODEC_ERR_TOOMUCHMETADATA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292334i32 as _);
pub const WINCODEC_ERR_UNEXPECTEDMETADATATYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292271i32 as _);
pub const WINCODEC_ERR_UNEXPECTEDSIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292273i32 as _);
pub const WINCODEC_ERR_UNKNOWNIMAGEFORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292409i32 as _);
pub const WINCODEC_ERR_UNSUPPORTEDOPERATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292287i32 as _);
pub const WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292288i32 as _);
pub const WINCODEC_ERR_UNSUPPORTEDVERSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292405i32 as _);
pub const WINCODEC_ERR_VALUEOUTOFRANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292411i32 as _);
pub const WINCODEC_ERR_WIN32ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292268i32 as _);
pub const WINCODEC_ERR_WRONGSTATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003292412i32 as _);
pub const WININET_E_ASYNC_THREAD_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012849i32 as _);
pub const WININET_E_BAD_AUTO_PROXY_SCRIPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012730i32 as _);
pub const WININET_E_BAD_OPTION_LENGTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012886i32 as _);
pub const WININET_E_BAD_REGISTRY_PARAMETER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012874i32 as _);
pub const WININET_E_CANNOT_CONNECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012867i32 as _);
pub const WININET_E_CHG_POST_IS_NON_SECURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012854i32 as _);
pub const WININET_E_CLIENT_AUTH_CERT_NEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012852i32 as _);
pub const WININET_E_CLIENT_AUTH_NOT_SETUP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012850i32 as _);
pub const WININET_E_CONNECTION_ABORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012866i32 as _);
pub const WININET_E_CONNECTION_RESET: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012865i32 as _);
pub const WININET_E_COOKIE_DECLINED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012734i32 as _);
pub const WININET_E_COOKIE_NEEDS_CONFIRMATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012735i32 as _);
pub const WININET_E_DECODING_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012721i32 as _);
pub const WININET_E_DIALOG_PENDING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012847i32 as _);
pub const WININET_E_DISCONNECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012733i32 as _);
pub const WININET_E_DOWNLEVEL_SERVER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012745i32 as _);
pub const WININET_E_EXTENDED_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012893i32 as _);
pub const WININET_E_FAILED_DUETOSECURITYCHECK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012725i32 as _);
pub const WININET_E_FORCE_RETRY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012864i32 as _);
pub const WININET_E_HANDLE_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012860i32 as _);
pub const WININET_E_HEADER_ALREADY_EXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012741i32 as _);
pub const WININET_E_HEADER_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012746i32 as _);
pub const WININET_E_HTTPS_HTTP_SUBMIT_REDIR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012844i32 as _);
pub const WININET_E_HTTPS_TO_HTTP_ON_REDIR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012856i32 as _);
pub const WININET_E_HTTP_TO_HTTPS_ON_REDIR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012857i32 as _);
pub const WININET_E_INCORRECT_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012869i32 as _);
pub const WININET_E_INCORRECT_HANDLE_STATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012877i32 as _);
pub const WININET_E_INCORRECT_HANDLE_TYPE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012878i32 as _);
pub const WININET_E_INCORRECT_PASSWORD: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012882i32 as _);
pub const WININET_E_INCORRECT_USER_NAME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012883i32 as _);
pub const WININET_E_INTERNAL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012892i32 as _);
pub const WININET_E_INVALID_CA: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012851i32 as _);
pub const WININET_E_INVALID_HEADER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012743i32 as _);
pub const WININET_E_INVALID_OPERATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012880i32 as _);
pub const WININET_E_INVALID_OPTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012887i32 as _);
pub const WININET_E_INVALID_PROXY_REQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012863i32 as _);
pub const WININET_E_INVALID_QUERY_REQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012742i32 as _);
pub const WININET_E_INVALID_SERVER_RESPONSE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012744i32 as _);
pub const WININET_E_INVALID_URL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012891i32 as _);
pub const WININET_E_ITEM_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012868i32 as _);
pub const WININET_E_LOGIN_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012881i32 as _);
pub const WININET_E_LOGIN_FAILURE_DISPLAY_ENTITY_BODY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012722i32 as _);
pub const WININET_E_MIXED_SECURITY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012855i32 as _);
pub const WININET_E_NAME_NOT_RESOLVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012889i32 as _);
pub const WININET_E_NEED_UI: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012862i32 as _);
pub const WININET_E_NOT_INITIALIZED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012724i32 as _);
pub const WININET_E_NOT_PROXY_REQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012876i32 as _);
pub const WININET_E_NOT_REDIRECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012736i32 as _);
pub const WININET_E_NO_CALLBACK: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012871i32 as _);
pub const WININET_E_NO_CONTEXT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012872i32 as _);
pub const WININET_E_NO_DIRECT_ACCESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012873i32 as _);
pub const WININET_E_NO_NEW_CONTAINERS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012845i32 as _);
pub const WININET_E_OPERATION_CANCELLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012879i32 as _);
pub const WININET_E_OPTION_NOT_SETTABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012885i32 as _);
pub const WININET_E_OUT_OF_HANDLES: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012895i32 as _);
pub const WININET_E_POST_IS_NON_SECURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012853i32 as _);
pub const WININET_E_PROTOCOL_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012888i32 as _);
pub const WININET_E_PROXY_SERVER_UNREACHABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012731i32 as _);
pub const WININET_E_REDIRECT_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012740i32 as _);
pub const WININET_E_REDIRECT_NEEDS_CONFIRMATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012728i32 as _);
pub const WININET_E_REDIRECT_SCHEME_CHANGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012848i32 as _);
pub const WININET_E_REGISTRY_VALUE_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012875i32 as _);
pub const WININET_E_REQUEST_PENDING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012870i32 as _);
pub const WININET_E_RETRY_DIALOG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012846i32 as _);
pub const WININET_E_SECURITY_CHANNEL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012739i32 as _);
pub const WININET_E_SEC_CERT_CN_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012858i32 as _);
pub const WININET_E_SEC_CERT_DATE_INVALID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012859i32 as _);
pub const WININET_E_SEC_CERT_ERRORS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012841i32 as _);
pub const WININET_E_SEC_CERT_REVOKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012726i32 as _);
pub const WININET_E_SEC_CERT_REV_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012839i32 as _);
pub const WININET_E_SEC_INVALID_CERT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012727i32 as _);
pub const WININET_E_SERVER_UNREACHABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012732i32 as _);
pub const WININET_E_SHUTDOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012884i32 as _);
pub const WININET_E_TCPIP_NOT_INSTALLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012737i32 as _);
pub const WININET_E_TIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012894i32 as _);
pub const WININET_E_UNABLE_TO_CACHE_FILE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012738i32 as _);
pub const WININET_E_UNABLE_TO_DOWNLOAD_SCRIPT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012729i32 as _);
pub const WININET_E_UNRECOGNIZED_SCHEME: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147012890i32 as _);
pub const WINML_ERR_INVALID_BINDING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003828734i32 as _);
pub const WINML_ERR_INVALID_DEVICE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003828735i32 as _);
pub const WINML_ERR_SIZE_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003828732i32 as _);
pub const WINML_ERR_VALUE_NOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2003828733i32 as _);
pub const WINVER: u32 = 1280u32;
pub const WINVER_MAXVER: u32 = 2560u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy, :: core :: fmt :: Debug, :: core :: cmp :: PartialEq, :: core :: cmp :: Eq)]
#[repr(transparent)]
pub struct WPARAM(pub usize);
impl ::core::default::Default for WPARAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
unsafe impl ::windows::core::Handle for WPARAM {}
unsafe impl ::windows::core::Abi for WPARAM {
type Abi = Self;
}
pub const WPN_E_ACCESS_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420137i32 as _);
pub const WPN_E_ALL_URL_NOT_COMPLETED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143419901i32 as _);
pub const WPN_E_CALLBACK_ALREADY_REGISTERED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143419898i32 as _);
pub const WPN_E_CHANNEL_CLOSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420160i32 as _);
pub const WPN_E_CHANNEL_REQUEST_NOT_COMPLETE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420159i32 as _);
pub const WPN_E_CLOUD_AUTH_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420134i32 as _);
pub const WPN_E_CLOUD_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420151i32 as _);
pub const WPN_E_CLOUD_DISABLED_FOR_APP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143419893i32 as _);
pub const WPN_E_CLOUD_INCAPABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420144i32 as _);
pub const WPN_E_CLOUD_SERVICE_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420133i32 as _);
pub const WPN_E_DEV_ID_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420128i32 as _);
pub const WPN_E_DUPLICATE_CHANNEL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420156i32 as _);
pub const WPN_E_DUPLICATE_REGISTRATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420136i32 as _);
pub const WPN_E_FAILED_LOCK_SCREEN_UPDATE_INTIALIZATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420132i32 as _);
pub const WPN_E_GROUP_ALPHANUMERIC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143419894i32 as _);
pub const WPN_E_GROUP_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143419895i32 as _);
pub const WPN_E_IMAGE_NOT_FOUND_IN_CACHE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143419902i32 as _);
pub const WPN_E_INTERNET_INCAPABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420141i32 as _);
pub const WPN_E_INVALID_APP: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420158i32 as _);
pub const WPN_E_INVALID_CLOUD_IMAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143419900i32 as _);
pub const WPN_E_INVALID_HTTP_STATUS_CODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420117i32 as _);
pub const WPN_E_NOTIFICATION_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420143i32 as _);
pub const WPN_E_NOTIFICATION_HIDDEN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420153i32 as _);
pub const WPN_E_NOTIFICATION_ID_MATCHED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143419899i32 as _);
pub const WPN_E_NOTIFICATION_INCAPABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420142i32 as _);
pub const WPN_E_NOTIFICATION_NOT_POSTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420152i32 as _);
pub const WPN_E_NOTIFICATION_POSTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420154i32 as _);
pub const WPN_E_NOTIFICATION_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420139i32 as _);
pub const WPN_E_NOTIFICATION_TYPE_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420140i32 as _);
pub const WPN_E_OUTSTANDING_CHANNEL_REQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420157i32 as _);
pub const WPN_E_OUT_OF_SESSION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143419904i32 as _);
pub const WPN_E_PLATFORM_UNAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420155i32 as _);
pub const WPN_E_POWER_SAVE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143419903i32 as _);
pub const WPN_E_PUSH_NOTIFICATION_INCAPABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420135i32 as _);
pub const WPN_E_STORAGE_LOCKED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143419896i32 as _);
pub const WPN_E_TAG_ALPHANUMERIC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420118i32 as _);
pub const WPN_E_TAG_SIZE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143420138i32 as _);
pub const WPN_E_TOAST_NOTIFICATION_DROPPED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143419897i32 as _);
pub const WS_E_ADDRESS_IN_USE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485941i32 as _);
pub const WS_E_ADDRESS_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485940i32 as _);
pub const WS_E_ENDPOINT_ACCESS_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485947i32 as _);
pub const WS_E_ENDPOINT_ACTION_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485935i32 as _);
pub const WS_E_ENDPOINT_DISCONNECTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485932i32 as _);
pub const WS_E_ENDPOINT_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485937i32 as _);
pub const WS_E_ENDPOINT_FAULT_RECEIVED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485933i32 as _);
pub const WS_E_ENDPOINT_NOT_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485938i32 as _);
pub const WS_E_ENDPOINT_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485939i32 as _);
pub const WS_E_ENDPOINT_TOO_BUSY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485934i32 as _);
pub const WS_E_ENDPOINT_UNREACHABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485936i32 as _);
pub const WS_E_INVALID_ENDPOINT_URL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485920i32 as _);
pub const WS_E_INVALID_FORMAT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485952i32 as _);
pub const WS_E_INVALID_OPERATION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485949i32 as _);
pub const WS_E_NOT_SUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485929i32 as _);
pub const WS_E_NO_TRANSLATION_AVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485943i32 as _);
pub const WS_E_NUMERIC_OVERFLOW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485950i32 as _);
pub const WS_E_OBJECT_FAULTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485951i32 as _);
pub const WS_E_OPERATION_ABANDONED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485945i32 as _);
pub const WS_E_OPERATION_ABORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485948i32 as _);
pub const WS_E_OPERATION_TIMED_OUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485946i32 as _);
pub const WS_E_OTHER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485919i32 as _);
pub const WS_E_PROXY_ACCESS_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485930i32 as _);
pub const WS_E_PROXY_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485931i32 as _);
pub const WS_E_PROXY_REQUIRES_BASIC_AUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485928i32 as _);
pub const WS_E_PROXY_REQUIRES_DIGEST_AUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485927i32 as _);
pub const WS_E_PROXY_REQUIRES_NEGOTIATE_AUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485925i32 as _);
pub const WS_E_PROXY_REQUIRES_NTLM_AUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485926i32 as _);
pub const WS_E_QUOTA_EXCEEDED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485944i32 as _);
pub const WS_E_SECURITY_SYSTEM_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485917i32 as _);
pub const WS_E_SECURITY_TOKEN_EXPIRED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485918i32 as _);
pub const WS_E_SECURITY_VERIFICATION_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485942i32 as _);
pub const WS_E_SERVER_REQUIRES_BASIC_AUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485924i32 as _);
pub const WS_E_SERVER_REQUIRES_DIGEST_AUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485923i32 as _);
pub const WS_E_SERVER_REQUIRES_NEGOTIATE_AUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485921i32 as _);
pub const WS_E_SERVER_REQUIRES_NTLM_AUTH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2143485922i32 as _);
pub const WS_S_ASYNC: ::windows::core::HRESULT = ::windows::core::HRESULT(3997696i32 as _);
pub const WS_S_END: ::windows::core::HRESULT = ::windows::core::HRESULT(3997697i32 as _);
pub const XACT_E_ABORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168231i32 as _);
pub const XACT_E_ABORTING: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168215i32 as _);
pub const XACT_E_ALREADYINPROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168232i32 as _);
pub const XACT_E_ALREADYOTHERSINGLEPHASE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168256i32 as _);
pub const XACT_E_CANTRETAIN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168255i32 as _);
pub const XACT_E_CLERKEXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168127i32 as _);
pub const XACT_E_CLERKNOTFOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168128i32 as _);
pub const XACT_E_COMMITFAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168254i32 as _);
pub const XACT_E_COMMITPREVENTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168253i32 as _);
pub const XACT_E_CONNECTION_DENIED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168227i32 as _);
pub const XACT_E_CONNECTION_DOWN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168228i32 as _);
pub const XACT_E_DEST_TMNOTAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168222i32 as _);
pub const XACT_E_FIRST: u32 = 2147799040u32;
pub const XACT_E_HEURISTICABORT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168252i32 as _);
pub const XACT_E_HEURISTICCOMMIT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168251i32 as _);
pub const XACT_E_HEURISTICDAMAGE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168250i32 as _);
pub const XACT_E_HEURISTICDANGER: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168249i32 as _);
pub const XACT_E_INDOUBT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168234i32 as _);
pub const XACT_E_INVALIDCOOKIE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168235i32 as _);
pub const XACT_E_INVALIDLSN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168124i32 as _);
pub const XACT_E_ISOLATIONLEVEL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168248i32 as _);
pub const XACT_E_LAST: u32 = 2147799083u32;
pub const XACT_E_LOGFULL: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168230i32 as _);
pub const XACT_E_LU_TX_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168212i32 as _);
pub const XACT_E_NETWORK_TX_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168220i32 as _);
pub const XACT_E_NOASYNC: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168247i32 as _);
pub const XACT_E_NOENLIST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168246i32 as _);
pub const XACT_E_NOIMPORTOBJECT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168236i32 as _);
pub const XACT_E_NOISORETAIN: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168245i32 as _);
pub const XACT_E_NORESOURCE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168244i32 as _);
pub const XACT_E_NOTCURRENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168243i32 as _);
pub const XACT_E_NOTIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168233i32 as _);
pub const XACT_E_NOTRANSACTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168242i32 as _);
pub const XACT_E_NOTSUPPORTED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168241i32 as _);
pub const XACT_E_PARTNER_NETWORK_TX_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168219i32 as _);
pub const XACT_E_PULL_COMM_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168213i32 as _);
pub const XACT_E_PUSH_COMM_FAILURE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168214i32 as _);
pub const XACT_E_RECOVERYINPROGRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168126i32 as _);
pub const XACT_E_REENLISTTIMEOUT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168226i32 as _);
pub const XACT_E_REPLAYREQUEST: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168123i32 as _);
pub const XACT_E_TIP_CONNECT_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168225i32 as _);
pub const XACT_E_TIP_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168221i32 as _);
pub const XACT_E_TIP_PROTOCOL_ERROR: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168224i32 as _);
pub const XACT_E_TIP_PULL_FAILED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168223i32 as _);
pub const XACT_E_TMNOTAVAILABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168229i32 as _);
pub const XACT_E_TRANSACTIONCLOSED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168125i32 as _);
pub const XACT_E_UNABLE_TO_LOAD_DTC_PROXY: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168216i32 as _);
pub const XACT_E_UNABLE_TO_READ_DTC_CONFIG: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168217i32 as _);
pub const XACT_E_UNKNOWNRMGRID: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168240i32 as _);
pub const XACT_E_WRONGSTATE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168239i32 as _);
pub const XACT_E_WRONGUOW: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168238i32 as _);
pub const XACT_E_XA_TX_DISABLED: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168218i32 as _);
pub const XACT_E_XTIONEXISTS: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147168237i32 as _);
pub const XACT_S_ABORTING: ::windows::core::HRESULT = ::windows::core::HRESULT(315400i32 as _);
pub const XACT_S_ALLNORETAIN: ::windows::core::HRESULT = ::windows::core::HRESULT(315399i32 as _);
pub const XACT_S_ASYNC: ::windows::core::HRESULT = ::windows::core::HRESULT(315392i32 as _);
pub const XACT_S_DEFECT: ::windows::core::HRESULT = ::windows::core::HRESULT(315393i32 as _);
pub const XACT_S_FIRST: u32 = 315392u32;
pub const XACT_S_LAST: u32 = 315408u32;
pub const XACT_S_LASTRESOURCEMANAGER: ::windows::core::HRESULT = ::windows::core::HRESULT(315408i32 as _);
pub const XACT_S_LOCALLY_OK: ::windows::core::HRESULT = ::windows::core::HRESULT(315402i32 as _);
pub const XACT_S_MADECHANGESCONTENT: ::windows::core::HRESULT = ::windows::core::HRESULT(315397i32 as _);
pub const XACT_S_MADECHANGESINFORM: ::windows::core::HRESULT = ::windows::core::HRESULT(315398i32 as _);
pub const XACT_S_OKINFORM: ::windows::core::HRESULT = ::windows::core::HRESULT(315396i32 as _);
pub const XACT_S_READONLY: ::windows::core::HRESULT = ::windows::core::HRESULT(315394i32 as _);
pub const XACT_S_SINGLEPHASE: ::windows::core::HRESULT = ::windows::core::HRESULT(315401i32 as _);
pub const XACT_S_SOMENORETAIN: ::windows::core::HRESULT = ::windows::core::HRESULT(315395i32 as _);
pub const XENROLL_E_CANNOT_ADD_ROOT_CERT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146873343i32 as _);
pub const XENROLL_E_KEYSPEC_SMIME_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146873339i32 as _);
pub const XENROLL_E_KEY_NOT_EXPORTABLE: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146873344i32 as _);
pub const XENROLL_E_RESPONSE_KA_HASH_MISMATCH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146873340i32 as _);
pub const XENROLL_E_RESPONSE_KA_HASH_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146873342i32 as _);
pub const XENROLL_E_RESPONSE_UNEXPECTED_KA_HASH: ::windows::core::HRESULT = ::windows::core::HRESULT(-2146873341i32 as _);
pub const _WIN32_IE_MAXVER: u32 = 2560u32;
pub const _WIN32_MAXVER: u32 = 2560u32;
pub const _WIN32_WINDOWS_MAXVER: u32 = 2560u32;
pub const _WIN32_WINNT_MAXVER: u32 = 2560u32;
|
#[derive(Clone)]
pub enum Yaml {
String(String),
Int(i64),
List(Vec<Yaml>),
Map(Vec<(String, Yaml)>),
Bool(bool),
}
impl Yaml {
pub fn to_yaml_rust(&self) -> yaml_rust::Yaml {
match self {
Yaml::String(s) => yaml_rust::Yaml::String(s.clone()),
Yaml::List(l) => yaml_rust::Yaml::Array(l.iter().map(|i| i.to_yaml_rust()).collect()),
Yaml::Map(m) => yaml_rust::Yaml::Hash(
m.iter()
.map(|(k, v)| (yaml_rust::Yaml::String(k.clone()), v.to_yaml_rust()))
.collect(),
),
Yaml::Int(i) => yaml_rust::Yaml::Integer(*i),
Yaml::Bool(b) => yaml_rust::Yaml::Boolean(*b),
}
}
}
impl From<&Yaml> for Yaml {
fn from(y: &Yaml) -> Self {
y.clone()
}
}
impl From<String> for Yaml {
fn from(s: String) -> Self {
Yaml::String(s)
}
}
impl From<&str> for Yaml {
fn from(s: &str) -> Self {
Yaml::String(s.to_owned())
}
}
impl From<&&str> for Yaml {
fn from(s: &&str) -> Self {
Yaml::String((*s).to_owned())
}
}
impl From<bool> for Yaml {
fn from(b: bool) -> Self {
Yaml::Bool(b)
}
}
impl<T: Into<Yaml>> From<Vec<T>> for Yaml {
fn from(v: Vec<T>) -> Self {
Yaml::List(v.into_iter().map(|t| t.into()).collect())
}
}
impl Yaml {
pub fn map<K: Into<String>, V: Into<Yaml>, E: IntoIterator<Item = (K, V)>>(entries: E) -> Yaml {
Yaml::Map(
entries
.into_iter()
.map(|(k, v)| (k.into(), v.into()))
.collect(),
)
}
pub fn list<V: Into<Yaml>, E: IntoIterator<Item = V>>(values: E) -> Yaml {
Yaml::List(values.into_iter().map(|v| v.into()).collect())
}
pub fn string<S: Into<String>>(s: S) -> Yaml {
Yaml::String(s.into())
}
}
#[derive(Default)]
pub struct YamlWriter {
pub buffer: String,
}
impl YamlWriter {
pub fn write_line(&mut self, line: &str) {
self.buffer.push_str(line);
self.buffer.push_str("\n");
}
pub fn write_yaml(&mut self, yaml: &Yaml) {
yaml_rust::emitter::YamlEmitter::new(&mut self.buffer)
.dump(&yaml.to_yaml_rust())
.unwrap();
}
}
|
// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use rustc::hir;
use rustc::mir::{BasicBlock, BasicBlockData, Location, Place, Mir, Rvalue};
use rustc::mir::visit::Visitor;
use rustc::mir::Place::Projection;
use rustc::mir::{Local, PlaceProjection, ProjectionElem};
use rustc::mir::visit::TyContext;
use rustc::infer::InferCtxt;
use rustc::traits::{self, ObligationCause};
use rustc::ty::{self, ClosureSubsts, Ty};
use rustc::ty::subst::Substs;
use rustc::ty::fold::TypeFoldable;
use rustc::util::common::ErrorReported;
use rustc_data_structures::fx::FxHashSet;
use syntax::codemap::DUMMY_SP;
use borrow_check::{FlowAtLocation, FlowsAtLocation};
use dataflow::MaybeInitializedLvals;
use dataflow::move_paths::{HasMoveData, MoveData};
use super::LivenessResults;
use super::ToRegionVid;
use super::region_infer::RegionInferenceContext;
pub(super) fn generate_constraints<'cx, 'gcx, 'tcx>(
infcx: &InferCtxt<'cx, 'gcx, 'tcx>,
regioncx: &mut RegionInferenceContext<'tcx>,
mir: &Mir<'tcx>,
param_env: ty::ParamEnv<'tcx>,
liveness: &LivenessResults,
flow_inits: &mut FlowAtLocation<MaybeInitializedLvals<'cx, 'gcx, 'tcx>>,
move_data: &MoveData<'tcx>,
) {
let mut cg = ConstraintGeneration {
infcx,
regioncx,
mir,
liveness,
param_env,
flow_inits,
move_data,
};
for (bb, data) in mir.basic_blocks().iter_enumerated() {
cg.visit_basic_block_data(bb, data);
}
}
/// 'cg = the duration of the constraint generation process itself.
struct ConstraintGeneration<'cg, 'cx: 'cg, 'gcx: 'tcx, 'tcx: 'cx> {
infcx: &'cg InferCtxt<'cx, 'gcx, 'tcx>,
regioncx: &'cg mut RegionInferenceContext<'tcx>,
mir: &'cg Mir<'tcx>,
liveness: &'cg LivenessResults,
param_env: ty::ParamEnv<'tcx>,
flow_inits: &'cg mut FlowAtLocation<MaybeInitializedLvals<'cx, 'gcx, 'tcx>>,
move_data: &'cg MoveData<'tcx>,
}
impl<'cg, 'cx, 'gcx, 'tcx> Visitor<'tcx> for ConstraintGeneration<'cg, 'cx, 'gcx, 'tcx> {
fn visit_basic_block_data(&mut self, bb: BasicBlock, data: &BasicBlockData<'tcx>) {
self.add_liveness_constraints(bb);
self.super_basic_block_data(bb, data);
}
/// We sometimes have `substs` within an rvalue, or within a
/// call. Make them live at the location where they appear.
fn visit_substs(&mut self, substs: &&'tcx Substs<'tcx>, location: Location) {
self.add_regular_live_constraint(*substs, location);
self.super_substs(substs);
}
/// We sometimes have `region` within an rvalue, or within a
/// call. Make them live at the location where they appear.
fn visit_region(&mut self, region: &ty::Region<'tcx>, location: Location) {
self.add_regular_live_constraint(*region, location);
self.super_region(region);
}
/// We sometimes have `ty` within an rvalue, or within a
/// call. Make them live at the location where they appear.
fn visit_ty(&mut self, ty: &ty::Ty<'tcx>, ty_context: TyContext) {
match ty_context {
TyContext::ReturnTy(source_info) |
TyContext::LocalDecl { source_info, .. } => {
span_bug!(source_info.span,
"should not be visiting outside of the CFG: {:?}",
ty_context);
}
TyContext::Location(location) => {
self.add_regular_live_constraint(*ty, location);
}
}
self.super_ty(ty);
}
/// We sometimes have `closure_substs` within an rvalue, or within a
/// call. Make them live at the location where they appear.
fn visit_closure_substs(&mut self, substs: &ClosureSubsts<'tcx>, location: Location) {
self.add_regular_live_constraint(*substs, location);
self.super_closure_substs(substs);
}
fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
debug!("visit_rvalue(rvalue={:?}, location={:?})", rvalue, location);
// Look for an rvalue like:
//
// & L
//
// where L is the path that is borrowed. In that case, we have
// to add the reborrow constraints (which don't fall out
// naturally from the type-checker).
if let Rvalue::Ref(region, _bk, ref borrowed_lv) = *rvalue {
self.add_reborrow_constraint(location, region, borrowed_lv);
}
self.super_rvalue(rvalue, location);
}
}
impl<'cx, 'cg, 'gcx, 'tcx> ConstraintGeneration<'cx, 'cg, 'gcx, 'tcx> {
/// Liveness constraints:
///
/// > If a variable V is live at point P, then all regions R in the type of V
/// > must include the point P.
fn add_liveness_constraints(&mut self, bb: BasicBlock) {
debug!("add_liveness_constraints(bb={:?})", bb);
self.liveness
.regular
.simulate_block(self.mir, bb, |location, live_locals| {
for live_local in live_locals.iter() {
let live_local_ty = self.mir.local_decls[live_local].ty;
self.add_regular_live_constraint(live_local_ty, location);
}
});
let mut all_live_locals: Vec<(Location, Vec<Local>)> = vec![];
self.liveness
.drop
.simulate_block(self.mir, bb, |location, live_locals| {
all_live_locals.push((location, live_locals.iter().collect()));
});
debug!(
"add_liveness_constraints: all_live_locals={:#?}",
all_live_locals
);
let terminator_index = self.mir.basic_blocks()[bb].statements.len();
self.flow_inits.reset_to_entry_of(bb);
while let Some((location, live_locals)) = all_live_locals.pop() {
for live_local in live_locals {
debug!(
"add_liveness_constraints: location={:?} live_local={:?}",
location,
live_local
);
self.flow_inits.each_state_bit(|mpi_init| {
debug!(
"add_liveness_constraints: location={:?} initialized={:?}",
location,
&self.flow_inits
.operator()
.move_data()
.move_paths[mpi_init]
);
});
let mpi = self.move_data.rev_lookup.find_local(live_local);
if let Some(initialized_child) = self.flow_inits.has_any_child_of(mpi) {
debug!(
"add_liveness_constraints: mpi={:?} has initialized child {:?}",
self.move_data.move_paths[mpi],
self.move_data.move_paths[initialized_child]
);
let live_local_ty = self.mir.local_decls[live_local].ty;
self.add_drop_live_constraint(live_local_ty, location);
}
}
if location.statement_index == terminator_index {
debug!(
"add_liveness_constraints: reconstruct_terminator_effect from {:#?}",
location
);
self.flow_inits.reconstruct_terminator_effect(location);
} else {
debug!(
"add_liveness_constraints: reconstruct_statement_effect from {:#?}",
location
);
self.flow_inits.reconstruct_statement_effect(location);
}
self.flow_inits.apply_local_effect(location);
}
}
/// Some variable with type `live_ty` is "regular live" at
/// `location` -- i.e., it may be used later. This means that all
/// regions appearing in the type `live_ty` must be live at
/// `location`.
fn add_regular_live_constraint<T>(&mut self, live_ty: T, location: Location)
where
T: TypeFoldable<'tcx>,
{
debug!(
"add_regular_live_constraint(live_ty={:?}, location={:?})",
live_ty,
location
);
self.infcx
.tcx
.for_each_free_region(&live_ty, |live_region| {
let vid = live_region.to_region_vid();
self.regioncx.add_live_point(vid, location);
});
}
/// Some variable with type `live_ty` is "drop live" at `location`
/// -- i.e., it may be dropped later. This means that *some* of
/// the regions in its type must be live at `location`. The
/// precise set will depend on the dropck constraints, and in
/// particular this takes `#[may_dangle]` into account.
fn add_drop_live_constraint(&mut self, dropped_ty: Ty<'tcx>, location: Location) {
debug!(
"add_drop_live_constraint(dropped_ty={:?}, location={:?})",
dropped_ty,
location
);
let tcx = self.infcx.tcx;
let mut types = vec![(dropped_ty, 0)];
let mut known = FxHashSet();
while let Some((ty, depth)) = types.pop() {
let span = DUMMY_SP; // FIXME
let result = match tcx.dtorck_constraint_for_ty(span, dropped_ty, depth, ty) {
Ok(result) => result,
Err(ErrorReported) => {
continue;
}
};
let ty::DtorckConstraint {
outlives,
dtorck_types,
} = result;
// All things in the `outlives` array may be touched by
// the destructor and must be live at this point.
for outlive in outlives {
self.add_regular_live_constraint(outlive, location);
}
// However, there may also be some types that
// `dtorck_constraint_for_ty` could not resolve (e.g.,
// associated types and parameters). We need to normalize
// associated types here and possibly recursively process.
for ty in dtorck_types {
let cause = ObligationCause::dummy();
// We know that our original `dropped_ty` is well-formed,
// so region obligations resulting from this normalization
// should always hold.
//
// Therefore we ignore them instead of trying to match
// them up with a location.
let fulfillcx = traits::FulfillmentContext::new_ignoring_regions();
match traits::fully_normalize_with_fulfillcx(
self.infcx, fulfillcx, cause, self.param_env, &ty
) {
Ok(ty) => match ty.sty {
ty::TyParam(..) | ty::TyProjection(..) | ty::TyAnon(..) => {
self.add_regular_live_constraint(ty, location);
}
_ => if known.insert(ty) {
types.push((ty, depth + 1));
},
},
Err(errors) => {
self.infcx.report_fulfillment_errors(&errors, None);
}
}
}
}
}
fn add_reborrow_constraint(
&mut self,
location: Location,
borrow_region: ty::Region<'tcx>,
borrowed_place: &Place<'tcx>,
) {
if let Projection(ref proj) = *borrowed_place {
let PlaceProjection { ref base, ref elem } = **proj;
if let ProjectionElem::Deref = *elem {
let tcx = self.infcx.tcx;
let base_ty = base.ty(self.mir, tcx).to_ty(tcx);
let base_sty = &base_ty.sty;
if let ty::TyRef(base_region, ty::TypeAndMut { ty: _, mutbl }) = *base_sty {
match mutbl {
hir::Mutability::MutImmutable => {}
hir::Mutability::MutMutable => {
self.add_reborrow_constraint(location, borrow_region, base);
}
}
let span = self.mir.source_info(location).span;
self.regioncx.add_outlives(
span,
base_region.to_region_vid(),
borrow_region.to_region_vid(),
location.successor_within_block(),
);
}
}
}
}
}
|
#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals, clashing_extern_declarations, clippy::all)]
#[cfg(feature = "Win32_Graphics_Printing_PrintTicket")]
pub mod PrintTicket;
#[link(name = "windows")]
extern "system" {
#[cfg(feature = "Win32_Foundation")]
pub fn AbortPrinter(hprinter: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddFormA(hprinter: super::super::Foundation::HANDLE, level: u32, pform: *const u8) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddFormW(hprinter: super::super::Foundation::HANDLE, level: u32, pform: *const u8) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddJobA(hprinter: super::super::Foundation::HANDLE, level: u32, pdata: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddJobW(hprinter: super::super::Foundation::HANDLE, level: u32, pdata: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddMonitorA(pname: super::super::Foundation::PSTR, level: u32, pmonitors: *const u8) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddMonitorW(pname: super::super::Foundation::PWSTR, level: u32, pmonitors: *const u8) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPortA(pname: super::super::Foundation::PSTR, hwnd: super::super::Foundation::HWND, pmonitorname: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPortW(pname: super::super::Foundation::PWSTR, hwnd: super::super::Foundation::HWND, pmonitorname: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrintDeviceObject(hprinter: super::super::Foundation::HANDLE, phdeviceobject: *mut super::super::Foundation::HANDLE) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrintProcessorA(pname: super::super::Foundation::PSTR, penvironment: super::super::Foundation::PSTR, ppathname: super::super::Foundation::PSTR, pprintprocessorname: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrintProcessorW(pname: super::super::Foundation::PWSTR, penvironment: super::super::Foundation::PWSTR, ppathname: super::super::Foundation::PWSTR, pprintprocessorname: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrintProvidorA(pname: super::super::Foundation::PSTR, level: u32, pprovidorinfo: *const u8) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrintProvidorW(pname: super::super::Foundation::PWSTR, level: u32, pprovidorinfo: *const u8) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrinterA(pname: super::super::Foundation::PSTR, level: u32, pprinter: *const u8) -> super::super::Foundation::HANDLE;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrinterConnection2A(hwnd: super::super::Foundation::HWND, pszname: super::super::Foundation::PSTR, dwlevel: u32, pconnectioninfo: *const ::core::ffi::c_void) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrinterConnection2W(hwnd: super::super::Foundation::HWND, pszname: super::super::Foundation::PWSTR, dwlevel: u32, pconnectioninfo: *const ::core::ffi::c_void) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrinterConnectionA(pname: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrinterConnectionW(pname: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrinterDriverA(pname: super::super::Foundation::PSTR, level: u32, pdriverinfo: *const u8) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrinterDriverExA(pname: super::super::Foundation::PSTR, level: u32, lpbdriverinfo: *const u8, dwfilecopyflags: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrinterDriverExW(pname: super::super::Foundation::PWSTR, level: u32, lpbdriverinfo: *const u8, dwfilecopyflags: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrinterDriverW(pname: super::super::Foundation::PWSTR, level: u32, pdriverinfo: *const u8) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn AddPrinterW(pname: super::super::Foundation::PWSTR, level: u32, pprinter: *const u8) -> super::super::Foundation::HANDLE;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn AdvancedDocumentPropertiesA(hwnd: super::super::Foundation::HWND, hprinter: super::super::Foundation::HANDLE, pdevicename: super::super::Foundation::PSTR, pdevmodeoutput: *mut super::Gdi::DEVMODEA, pdevmodeinput: *const super::Gdi::DEVMODEA) -> i32;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn AdvancedDocumentPropertiesW(hwnd: super::super::Foundation::HWND, hprinter: super::super::Foundation::HANDLE, pdevicename: super::super::Foundation::PWSTR, pdevmodeoutput: *mut super::Gdi::DEVMODEW, pdevmodeinput: *const super::Gdi::DEVMODEW) -> i32;
#[cfg(feature = "Win32_Foundation")]
pub fn AppendPrinterNotifyInfoData(pinfodest: *const PRINTER_NOTIFY_INFO, pdatasrc: *const PRINTER_NOTIFY_INFO_DATA, fdwflags: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn CallRouterFindFirstPrinterChangeNotification(hprinterrpc: super::super::Foundation::HANDLE, fdwfilterflags: u32, fdwoptions: u32, hnotify: super::super::Foundation::HANDLE, pprinternotifyoptions: *const PRINTER_NOTIFY_OPTIONS) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn ClosePrinter(hprinter: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn CloseSpoolFileHandle(hprinter: super::super::Foundation::HANDLE, hspoolfile: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn CommitSpoolData(hprinter: super::super::Foundation::HANDLE, hspoolfile: super::super::Foundation::HANDLE, cbcommit: u32) -> super::super::Foundation::HANDLE;
#[cfg(feature = "Win32_Foundation")]
pub fn CommonPropertySheetUIA(hwndowner: super::super::Foundation::HWND, pfnpropsheetui: PFNPROPSHEETUI, lparam: super::super::Foundation::LPARAM, presult: *mut u32) -> i32;
#[cfg(feature = "Win32_Foundation")]
pub fn CommonPropertySheetUIW(hwndowner: super::super::Foundation::HWND, pfnpropsheetui: PFNPROPSHEETUI, lparam: super::super::Foundation::LPARAM, presult: *mut u32) -> i32;
#[cfg(feature = "Win32_Foundation")]
pub fn ConfigurePortA(pname: super::super::Foundation::PSTR, hwnd: super::super::Foundation::HWND, pportname: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn ConfigurePortW(pname: super::super::Foundation::PWSTR, hwnd: super::super::Foundation::HWND, pportname: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn ConnectToPrinterDlg(hwnd: super::super::Foundation::HWND, flags: u32) -> super::super::Foundation::HANDLE;
#[cfg(feature = "Win32_Foundation")]
pub fn CorePrinterDriverInstalledA(pszserver: super::super::Foundation::PSTR, pszenvironment: super::super::Foundation::PSTR, coredriverguid: ::windows_sys::core::GUID, ftdriverdate: super::super::Foundation::FILETIME, dwldriverversion: u64, pbdriverinstalled: *mut super::super::Foundation::BOOL) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn CorePrinterDriverInstalledW(pszserver: super::super::Foundation::PWSTR, pszenvironment: super::super::Foundation::PWSTR, coredriverguid: ::windows_sys::core::GUID, ftdriverdate: super::super::Foundation::FILETIME, dwldriverversion: u64, pbdriverinstalled: *mut super::super::Foundation::BOOL) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn CreatePrintAsyncNotifyChannel(pszname: super::super::Foundation::PWSTR, pnotificationtype: *const ::windows_sys::core::GUID, euserfilter: PrintAsyncNotifyUserFilter, econversationstyle: PrintAsyncNotifyConversationStyle, pcallback: IPrintAsyncNotifyCallback, ppiasynchnotification: *mut IPrintAsyncNotifyChannel) -> ::windows_sys::core::HRESULT;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn CreatePrinterIC(hprinter: super::super::Foundation::HANDLE, pdevmode: *const super::Gdi::DEVMODEW) -> super::super::Foundation::HANDLE;
#[cfg(feature = "Win32_Foundation")]
pub fn DeleteFormA(hprinter: super::super::Foundation::HANDLE, pformname: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeleteFormW(hprinter: super::super::Foundation::HANDLE, pformname: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeleteJobNamedProperty(hprinter: super::super::Foundation::HANDLE, jobid: u32, pszname: super::super::Foundation::PWSTR) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn DeleteMonitorA(pname: super::super::Foundation::PSTR, penvironment: super::super::Foundation::PSTR, pmonitorname: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeleteMonitorW(pname: super::super::Foundation::PWSTR, penvironment: super::super::Foundation::PWSTR, pmonitorname: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePortA(pname: super::super::Foundation::PSTR, hwnd: super::super::Foundation::HWND, pportname: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePortW(pname: super::super::Foundation::PWSTR, hwnd: super::super::Foundation::HWND, pportname: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrintProcessorA(pname: super::super::Foundation::PSTR, penvironment: super::super::Foundation::PSTR, pprintprocessorname: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrintProcessorW(pname: super::super::Foundation::PWSTR, penvironment: super::super::Foundation::PWSTR, pprintprocessorname: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrintProvidorA(pname: super::super::Foundation::PSTR, penvironment: super::super::Foundation::PSTR, pprintprovidorname: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrintProvidorW(pname: super::super::Foundation::PWSTR, penvironment: super::super::Foundation::PWSTR, pprintprovidorname: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinter(hprinter: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterConnectionA(pname: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterConnectionW(pname: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterDataA(hprinter: super::super::Foundation::HANDLE, pvaluename: super::super::Foundation::PSTR) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterDataExA(hprinter: super::super::Foundation::HANDLE, pkeyname: super::super::Foundation::PSTR, pvaluename: super::super::Foundation::PSTR) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterDataExW(hprinter: super::super::Foundation::HANDLE, pkeyname: super::super::Foundation::PWSTR, pvaluename: super::super::Foundation::PWSTR) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterDataW(hprinter: super::super::Foundation::HANDLE, pvaluename: super::super::Foundation::PWSTR) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterDriverA(pname: super::super::Foundation::PSTR, penvironment: super::super::Foundation::PSTR, pdrivername: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterDriverExA(pname: super::super::Foundation::PSTR, penvironment: super::super::Foundation::PSTR, pdrivername: super::super::Foundation::PSTR, dwdeleteflag: u32, dwversionflag: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterDriverExW(pname: super::super::Foundation::PWSTR, penvironment: super::super::Foundation::PWSTR, pdrivername: super::super::Foundation::PWSTR, dwdeleteflag: u32, dwversionflag: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterDriverPackageA(pszserver: super::super::Foundation::PSTR, pszinfpath: super::super::Foundation::PSTR, pszenvironment: super::super::Foundation::PSTR) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterDriverPackageW(pszserver: super::super::Foundation::PWSTR, pszinfpath: super::super::Foundation::PWSTR, pszenvironment: super::super::Foundation::PWSTR) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterDriverW(pname: super::super::Foundation::PWSTR, penvironment: super::super::Foundation::PWSTR, pdrivername: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterIC(hprinteric: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterKeyA(hprinter: super::super::Foundation::HANDLE, pkeyname: super::super::Foundation::PSTR) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn DeletePrinterKeyW(hprinter: super::super::Foundation::HANDLE, pkeyname: super::super::Foundation::PWSTR) -> u32;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn DevQueryPrint(hprinter: super::super::Foundation::HANDLE, pdevmode: *const super::Gdi::DEVMODEA, presid: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn DevQueryPrintEx(pdqpinfo: *mut DEVQUERYPRINT_INFO) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn DocumentPropertiesA(hwnd: super::super::Foundation::HWND, hprinter: super::super::Foundation::HANDLE, pdevicename: super::super::Foundation::PSTR, pdevmodeoutput: *mut super::Gdi::DEVMODEA, pdevmodeinput: *const super::Gdi::DEVMODEA, fmode: u32) -> i32;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn DocumentPropertiesW(hwnd: super::super::Foundation::HWND, hprinter: super::super::Foundation::HANDLE, pdevicename: super::super::Foundation::PWSTR, pdevmodeoutput: *mut super::Gdi::DEVMODEW, pdevmodeinput: *const super::Gdi::DEVMODEW, fmode: u32) -> i32;
#[cfg(feature = "Win32_Foundation")]
pub fn EndDocPrinter(hprinter: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EndPagePrinter(hprinter: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumFormsA(hprinter: super::super::Foundation::HANDLE, level: u32, pform: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumFormsW(hprinter: super::super::Foundation::HANDLE, level: u32, pform: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumJobNamedProperties(hprinter: super::super::Foundation::HANDLE, jobid: u32, pcproperties: *mut u32, ppproperties: *mut *mut PrintNamedProperty) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumJobsA(hprinter: super::super::Foundation::HANDLE, firstjob: u32, nojobs: u32, level: u32, pjob: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumJobsW(hprinter: super::super::Foundation::HANDLE, firstjob: u32, nojobs: u32, level: u32, pjob: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumMonitorsA(pname: super::super::Foundation::PSTR, level: u32, pmonitor: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumMonitorsW(pname: super::super::Foundation::PWSTR, level: u32, pmonitor: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPortsA(pname: super::super::Foundation::PSTR, level: u32, pport: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPortsW(pname: super::super::Foundation::PWSTR, level: u32, pport: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrintProcessorDatatypesA(pname: super::super::Foundation::PSTR, pprintprocessorname: super::super::Foundation::PSTR, level: u32, pdatatypes: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrintProcessorDatatypesW(pname: super::super::Foundation::PWSTR, pprintprocessorname: super::super::Foundation::PWSTR, level: u32, pdatatypes: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrintProcessorsA(pname: super::super::Foundation::PSTR, penvironment: super::super::Foundation::PSTR, level: u32, pprintprocessorinfo: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrintProcessorsW(pname: super::super::Foundation::PWSTR, penvironment: super::super::Foundation::PWSTR, level: u32, pprintprocessorinfo: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrinterDataA(hprinter: super::super::Foundation::HANDLE, dwindex: u32, pvaluename: super::super::Foundation::PSTR, cbvaluename: u32, pcbvaluename: *mut u32, ptype: *mut u32, pdata: *mut u8, cbdata: u32, pcbdata: *mut u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrinterDataExA(hprinter: super::super::Foundation::HANDLE, pkeyname: super::super::Foundation::PSTR, penumvalues: *mut u8, cbenumvalues: u32, pcbenumvalues: *mut u32, pnenumvalues: *mut u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrinterDataExW(hprinter: super::super::Foundation::HANDLE, pkeyname: super::super::Foundation::PWSTR, penumvalues: *mut u8, cbenumvalues: u32, pcbenumvalues: *mut u32, pnenumvalues: *mut u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrinterDataW(hprinter: super::super::Foundation::HANDLE, dwindex: u32, pvaluename: super::super::Foundation::PWSTR, cbvaluename: u32, pcbvaluename: *mut u32, ptype: *mut u32, pdata: *mut u8, cbdata: u32, pcbdata: *mut u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrinterDriversA(pname: super::super::Foundation::PSTR, penvironment: super::super::Foundation::PSTR, level: u32, pdriverinfo: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrinterDriversW(pname: super::super::Foundation::PWSTR, penvironment: super::super::Foundation::PWSTR, level: u32, pdriverinfo: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrinterKeyA(hprinter: super::super::Foundation::HANDLE, pkeyname: super::super::Foundation::PSTR, psubkey: super::super::Foundation::PSTR, cbsubkey: u32, pcbsubkey: *mut u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrinterKeyW(hprinter: super::super::Foundation::HANDLE, pkeyname: super::super::Foundation::PWSTR, psubkey: super::super::Foundation::PWSTR, cbsubkey: u32, pcbsubkey: *mut u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrintersA(flags: u32, name: super::super::Foundation::PSTR, level: u32, pprinterenum: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn EnumPrintersW(flags: u32, name: super::super::Foundation::PWSTR, level: u32, pprinterenum: *mut u8, cbbuf: u32, pcbneeded: *mut u32, pcreturned: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn ExtDeviceMode(hwnd: super::super::Foundation::HWND, hinst: super::super::Foundation::HANDLE, pdevmodeoutput: *mut super::Gdi::DEVMODEA, pdevicename: super::super::Foundation::PSTR, pport: super::super::Foundation::PSTR, pdevmodeinput: *const super::Gdi::DEVMODEA, pprofile: super::super::Foundation::PSTR, fmode: u32) -> i32;
#[cfg(feature = "Win32_Foundation")]
pub fn FindClosePrinterChangeNotification(hchange: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn FindFirstPrinterChangeNotification(hprinter: super::super::Foundation::HANDLE, fdwfilter: u32, fdwoptions: u32, pprinternotifyoptions: *const ::core::ffi::c_void) -> super::super::Foundation::HANDLE;
#[cfg(feature = "Win32_Foundation")]
pub fn FindNextPrinterChangeNotification(hchange: super::super::Foundation::HANDLE, pdwchange: *mut u32, pvreserved: *const ::core::ffi::c_void, ppprinternotifyinfo: *mut *mut ::core::ffi::c_void) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn FlushPrinter(hprinter: super::super::Foundation::HANDLE, pbuf: *const ::core::ffi::c_void, cbbuf: u32, pcwritten: *mut u32, csleep: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn FreePrintNamedPropertyArray(cproperties: u32, ppproperties: *mut *mut PrintNamedProperty);
#[cfg(feature = "Win32_Foundation")]
pub fn FreePrintPropertyValue(pvalue: *mut PrintPropertyValue);
#[cfg(feature = "Win32_Foundation")]
pub fn FreePrinterNotifyInfo(pprinternotifyinfo: *const PRINTER_NOTIFY_INFO) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GdiDeleteSpoolFileHandle(spoolfilehandle: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GdiEndDocEMF(spoolfilehandle: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GdiEndPageEMF(spoolfilehandle: super::super::Foundation::HANDLE, dwoptimization: u32) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn GdiGetDC(spoolfilehandle: super::super::Foundation::HANDLE) -> super::Gdi::HDC;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn GdiGetDevmodeForPage(spoolfilehandle: super::super::Foundation::HANDLE, dwpagenumber: u32, pcurrdm: *mut *mut super::Gdi::DEVMODEW, plastdm: *mut *mut super::Gdi::DEVMODEW) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GdiGetPageCount(spoolfilehandle: super::super::Foundation::HANDLE) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn GdiGetPageHandle(spoolfilehandle: super::super::Foundation::HANDLE, page: u32, pdwpagetype: *mut u32) -> super::super::Foundation::HANDLE;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn GdiGetSpoolFileHandle(pwszprintername: super::super::Foundation::PWSTR, pdevmode: *mut super::Gdi::DEVMODEW, pwszdocname: super::super::Foundation::PWSTR) -> super::super::Foundation::HANDLE;
#[cfg(feature = "Win32_Foundation")]
pub fn GdiPlayPageEMF(spoolfilehandle: super::super::Foundation::HANDLE, hemf: super::super::Foundation::HANDLE, prectdocument: *mut super::super::Foundation::RECT, prectborder: *mut super::super::Foundation::RECT, prectclip: *mut super::super::Foundation::RECT) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn GdiResetDCEMF(spoolfilehandle: super::super::Foundation::HANDLE, pcurrdm: *mut super::Gdi::DEVMODEW) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_Xps"))]
pub fn GdiStartDocEMF(spoolfilehandle: super::super::Foundation::HANDLE, pdocinfo: *mut super::super::Storage::Xps::DOCINFOW) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GdiStartPageEMF(spoolfilehandle: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GenerateCopyFilePaths(pszprintername: super::super::Foundation::PWSTR, pszdirectory: super::super::Foundation::PWSTR, psplclientinfo: *const u8, dwlevel: u32, pszsourcedir: super::super::Foundation::PWSTR, pcchsourcedirsize: *mut u32, psztargetdir: super::super::Foundation::PWSTR, pcchtargetdirsize: *mut u32, dwflags: u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn GetCPSUIUserData(hdlg: super::super::Foundation::HWND) -> usize;
#[cfg(feature = "Win32_Foundation")]
pub fn GetCorePrinterDriversA(pszserver: super::super::Foundation::PSTR, pszenvironment: super::super::Foundation::PSTR, pszzcoredriverdependencies: super::super::Foundation::PSTR, ccoreprinterdrivers: u32, pcoreprinterdrivers: *mut CORE_PRINTER_DRIVERA) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn GetCorePrinterDriversW(pszserver: super::super::Foundation::PWSTR, pszenvironment: super::super::Foundation::PWSTR, pszzcoredriverdependencies: super::super::Foundation::PWSTR, ccoreprinterdrivers: u32, pcoreprinterdrivers: *mut CORE_PRINTER_DRIVERW) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn GetDefaultPrinterA(pszbuffer: super::super::Foundation::PSTR, pcchbuffer: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetDefaultPrinterW(pszbuffer: super::super::Foundation::PWSTR, pcchbuffer: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetFormA(hprinter: super::super::Foundation::HANDLE, pformname: super::super::Foundation::PSTR, level: u32, pform: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetFormW(hprinter: super::super::Foundation::HANDLE, pformname: super::super::Foundation::PWSTR, level: u32, pform: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetJobA(hprinter: super::super::Foundation::HANDLE, jobid: u32, level: u32, pjob: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn GetJobAttributes(pprintername: super::super::Foundation::PWSTR, pdevmode: *const super::Gdi::DEVMODEW, pattributeinfo: *mut ATTRIBUTE_INFO_3) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn GetJobAttributesEx(pprintername: super::super::Foundation::PWSTR, pdevmode: *const super::Gdi::DEVMODEW, dwlevel: u32, pattributeinfo: *mut u8, nsize: u32, dwflags: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetJobNamedPropertyValue(hprinter: super::super::Foundation::HANDLE, jobid: u32, pszname: super::super::Foundation::PWSTR, pvalue: *mut PrintPropertyValue) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn GetJobW(hprinter: super::super::Foundation::HANDLE, jobid: u32, level: u32, pjob: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrintExecutionData(pdata: *mut PRINT_EXECUTION_DATA) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrintOutputInfo(hwnd: super::super::Foundation::HWND, pszprinter: super::super::Foundation::PWSTR, phfile: *mut super::super::Foundation::HANDLE, ppszoutputfile: *mut super::super::Foundation::PWSTR) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrintProcessorDirectoryA(pname: super::super::Foundation::PSTR, penvironment: super::super::Foundation::PSTR, level: u32, pprintprocessorinfo: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrintProcessorDirectoryW(pname: super::super::Foundation::PWSTR, penvironment: super::super::Foundation::PWSTR, level: u32, pprintprocessorinfo: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterA(hprinter: super::super::Foundation::HANDLE, level: u32, pprinter: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterDataA(hprinter: super::super::Foundation::HANDLE, pvaluename: super::super::Foundation::PSTR, ptype: *mut u32, pdata: *mut u8, nsize: u32, pcbneeded: *mut u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterDataExA(hprinter: super::super::Foundation::HANDLE, pkeyname: super::super::Foundation::PSTR, pvaluename: super::super::Foundation::PSTR, ptype: *mut u32, pdata: *mut u8, nsize: u32, pcbneeded: *mut u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterDataExW(hprinter: super::super::Foundation::HANDLE, pkeyname: super::super::Foundation::PWSTR, pvaluename: super::super::Foundation::PWSTR, ptype: *mut u32, pdata: *mut u8, nsize: u32, pcbneeded: *mut u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterDataW(hprinter: super::super::Foundation::HANDLE, pvaluename: super::super::Foundation::PWSTR, ptype: *mut u32, pdata: *mut u8, nsize: u32, pcbneeded: *mut u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterDriver2A(hwnd: super::super::Foundation::HWND, hprinter: super::super::Foundation::HANDLE, penvironment: super::super::Foundation::PSTR, level: u32, pdriverinfo: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterDriver2W(hwnd: super::super::Foundation::HWND, hprinter: super::super::Foundation::HANDLE, penvironment: super::super::Foundation::PWSTR, level: u32, pdriverinfo: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterDriverA(hprinter: super::super::Foundation::HANDLE, penvironment: super::super::Foundation::PSTR, level: u32, pdriverinfo: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterDriverDirectoryA(pname: super::super::Foundation::PSTR, penvironment: super::super::Foundation::PSTR, level: u32, pdriverdirectory: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterDriverDirectoryW(pname: super::super::Foundation::PWSTR, penvironment: super::super::Foundation::PWSTR, level: u32, pdriverdirectory: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterDriverPackagePathA(pszserver: super::super::Foundation::PSTR, pszenvironment: super::super::Foundation::PSTR, pszlanguage: super::super::Foundation::PSTR, pszpackageid: super::super::Foundation::PSTR, pszdriverpackagecab: super::super::Foundation::PSTR, cchdriverpackagecab: u32, pcchrequiredsize: *mut u32) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterDriverPackagePathW(pszserver: super::super::Foundation::PWSTR, pszenvironment: super::super::Foundation::PWSTR, pszlanguage: super::super::Foundation::PWSTR, pszpackageid: super::super::Foundation::PWSTR, pszdriverpackagecab: super::super::Foundation::PWSTR, cchdriverpackagecab: u32, pcchrequiredsize: *mut u32) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterDriverW(hprinter: super::super::Foundation::HANDLE, penvironment: super::super::Foundation::PWSTR, level: u32, pdriverinfo: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetPrinterW(hprinter: super::super::Foundation::HANDLE, level: u32, pprinter: *mut u8, cbbuf: u32, pcbneeded: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn GetSpoolFileHandle(hprinter: super::super::Foundation::HANDLE) -> super::super::Foundation::HANDLE;
#[cfg(feature = "Win32_Foundation")]
pub fn ImpersonatePrinterClient(htoken: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn InstallPrinterDriverFromPackageA(pszserver: super::super::Foundation::PSTR, pszinfpath: super::super::Foundation::PSTR, pszdrivername: super::super::Foundation::PSTR, pszenvironment: super::super::Foundation::PSTR, dwflags: u32) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn InstallPrinterDriverFromPackageW(pszserver: super::super::Foundation::PWSTR, pszinfpath: super::super::Foundation::PWSTR, pszdrivername: super::super::Foundation::PWSTR, pszenvironment: super::super::Foundation::PWSTR, dwflags: u32) -> ::windows_sys::core::HRESULT;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn IsValidDevmodeA(pdevmode: *const super::Gdi::DEVMODEA, devmodesize: usize) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn IsValidDevmodeW(pdevmode: *const super::Gdi::DEVMODEW, devmodesize: usize) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn OpenPrinter2A(pprintername: super::super::Foundation::PSTR, phprinter: *mut super::super::Foundation::HANDLE, pdefault: *const PRINTER_DEFAULTSA, poptions: *const PRINTER_OPTIONSA) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn OpenPrinter2W(pprintername: super::super::Foundation::PWSTR, phprinter: *mut super::super::Foundation::HANDLE, pdefault: *const PRINTER_DEFAULTSW, poptions: *const PRINTER_OPTIONSW) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn OpenPrinterA(pprintername: super::super::Foundation::PSTR, phprinter: *mut super::super::Foundation::HANDLE, pdefault: *const PRINTER_DEFAULTSA) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn OpenPrinterW(pprintername: super::super::Foundation::PWSTR, phprinter: *mut super::super::Foundation::HANDLE, pdefault: *const PRINTER_DEFAULTSW) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn PartialReplyPrinterChangeNotification(hprinter: super::super::Foundation::HANDLE, pdatasrc: *const PRINTER_NOTIFY_INFO_DATA) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn PlayGdiScriptOnPrinterIC(hprinteric: super::super::Foundation::HANDLE, pin: *const u8, cin: u32, pout: *mut u8, cout: u32, ul: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn PrinterMessageBoxA(hprinter: super::super::Foundation::HANDLE, error: u32, hwnd: super::super::Foundation::HWND, ptext: super::super::Foundation::PSTR, pcaption: super::super::Foundation::PSTR, dwtype: u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn PrinterMessageBoxW(hprinter: super::super::Foundation::HANDLE, error: u32, hwnd: super::super::Foundation::HWND, ptext: super::super::Foundation::PWSTR, pcaption: super::super::Foundation::PWSTR, dwtype: u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn PrinterProperties(hwnd: super::super::Foundation::HWND, hprinter: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn ProvidorFindClosePrinterChangeNotification(hprinter: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn ProvidorFindFirstPrinterChangeNotification(hprinter: super::super::Foundation::HANDLE, fdwflags: u32, fdwoptions: u32, hnotify: super::super::Foundation::HANDLE, pprinternotifyoptions: *const ::core::ffi::c_void, pvreserved1: *mut ::core::ffi::c_void) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn ReadPrinter(hprinter: super::super::Foundation::HANDLE, pbuf: *mut ::core::ffi::c_void, cbbuf: u32, pnobytesread: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn RegisterForPrintAsyncNotifications(pszname: super::super::Foundation::PWSTR, pnotificationtype: *const ::windows_sys::core::GUID, euserfilter: PrintAsyncNotifyUserFilter, econversationstyle: PrintAsyncNotifyConversationStyle, pcallback: IPrintAsyncNotifyCallback, phnotify: *mut super::super::Foundation::HANDLE) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn RemovePrintDeviceObject(hdeviceobject: super::super::Foundation::HANDLE) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn ReplyPrinterChangeNotification(hprinter: super::super::Foundation::HANDLE, fdwchangeflags: u32, pdwresult: *mut u32, pprinternotifyinfo: *const ::core::ffi::c_void) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn ReplyPrinterChangeNotificationEx(hnotify: super::super::Foundation::HANDLE, dwcolor: u32, fdwflags: u32, pdwresult: *mut u32, pprinternotifyinfo: *const ::core::ffi::c_void) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn ReportJobProcessingProgress(printerhandle: super::super::Foundation::HANDLE, jobid: u32, joboperation: EPrintXPSJobOperation, jobprogress: EPrintXPSJobProgress) -> ::windows_sys::core::HRESULT;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn ResetPrinterA(hprinter: super::super::Foundation::HANDLE, pdefault: *const PRINTER_DEFAULTSA) -> super::super::Foundation::BOOL;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub fn ResetPrinterW(hprinter: super::super::Foundation::HANDLE, pdefault: *const PRINTER_DEFAULTSW) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn RevertToPrinterSelf() -> super::super::Foundation::HANDLE;
pub fn RouterAllocBidiMem(numbytes: usize) -> *mut ::core::ffi::c_void;
#[cfg(feature = "Win32_Foundation")]
pub fn RouterAllocBidiResponseContainer(count: u32) -> *mut BIDI_RESPONSE_CONTAINER;
pub fn RouterAllocPrinterNotifyInfo(cprinternotifyinfodata: u32) -> *mut PRINTER_NOTIFY_INFO;
pub fn RouterFreeBidiMem(pmempointer: *const ::core::ffi::c_void);
#[cfg(feature = "Win32_Foundation")]
pub fn RouterFreeBidiResponseContainer(pdata: *const BIDI_RESPONSE_CONTAINER) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn RouterFreePrinterNotifyInfo(pinfo: *const PRINTER_NOTIFY_INFO) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn ScheduleJob(hprinter: super::super::Foundation::HANDLE, jobid: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SetCPSUIUserData(hdlg: super::super::Foundation::HWND, cpsuiuserdata: usize) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SetDefaultPrinterA(pszprinter: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SetDefaultPrinterW(pszprinter: super::super::Foundation::PWSTR) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SetFormA(hprinter: super::super::Foundation::HANDLE, pformname: super::super::Foundation::PSTR, level: u32, pform: *const u8) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SetFormW(hprinter: super::super::Foundation::HANDLE, pformname: super::super::Foundation::PWSTR, level: u32, pform: *const u8) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SetJobA(hprinter: super::super::Foundation::HANDLE, jobid: u32, level: u32, pjob: *mut u8, command: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SetJobNamedProperty(hprinter: super::super::Foundation::HANDLE, jobid: u32, pproperty: *const PrintNamedProperty) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn SetJobW(hprinter: super::super::Foundation::HANDLE, jobid: u32, level: u32, pjob: *mut u8, command: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SetPortA(pname: super::super::Foundation::PSTR, pportname: super::super::Foundation::PSTR, dwlevel: u32, pportinfo: *const u8) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SetPortW(pname: super::super::Foundation::PWSTR, pportname: super::super::Foundation::PWSTR, dwlevel: u32, pportinfo: *const u8) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SetPrinterA(hprinter: super::super::Foundation::HANDLE, level: u32, pprinter: *const u8, command: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SetPrinterDataA(hprinter: super::super::Foundation::HANDLE, pvaluename: super::super::Foundation::PSTR, r#type: u32, pdata: *const u8, cbdata: u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn SetPrinterDataExA(hprinter: super::super::Foundation::HANDLE, pkeyname: super::super::Foundation::PSTR, pvaluename: super::super::Foundation::PSTR, r#type: u32, pdata: *const u8, cbdata: u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn SetPrinterDataExW(hprinter: super::super::Foundation::HANDLE, pkeyname: super::super::Foundation::PWSTR, pvaluename: super::super::Foundation::PWSTR, r#type: u32, pdata: *const u8, cbdata: u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn SetPrinterDataW(hprinter: super::super::Foundation::HANDLE, pvaluename: super::super::Foundation::PWSTR, r#type: u32, pdata: *const u8, cbdata: u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn SetPrinterW(hprinter: super::super::Foundation::HANDLE, level: u32, pprinter: *const u8, command: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SplIsSessionZero(hprinter: super::super::Foundation::HANDLE, jobid: u32, pissessionzero: *mut super::super::Foundation::BOOL) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn SplPromptUIInUsersSession(hprinter: super::super::Foundation::HANDLE, jobid: u32, puiparams: *const SHOWUIPARAMS, presponse: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SpoolerCopyFileEvent(pszprintername: super::super::Foundation::PWSTR, pszkey: super::super::Foundation::PWSTR, dwcopyfileevent: u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SpoolerFindClosePrinterChangeNotification(hprinter: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SpoolerFindFirstPrinterChangeNotification(hprinter: super::super::Foundation::HANDLE, fdwfilterflags: u32, fdwoptions: u32, pprinternotifyoptions: *const ::core::ffi::c_void, pvreserved: *const ::core::ffi::c_void, pnotificationconfig: *const ::core::ffi::c_void, phnotify: *mut super::super::Foundation::HANDLE, phevent: *mut super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn SpoolerFindNextPrinterChangeNotification(hprinter: super::super::Foundation::HANDLE, pfdwchange: *mut u32, pprinternotifyoptions: *const ::core::ffi::c_void, ppprinternotifyinfo: *mut *mut ::core::ffi::c_void) -> super::super::Foundation::BOOL;
pub fn SpoolerFreePrinterNotifyInfo(pinfo: *const PRINTER_NOTIFY_INFO);
#[cfg(feature = "Win32_Foundation")]
pub fn SpoolerRefreshPrinterChangeNotification(hprinter: super::super::Foundation::HANDLE, dwcolor: u32, poptions: *const PRINTER_NOTIFY_OPTIONS, ppinfo: *mut *mut PRINTER_NOTIFY_INFO) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn StartDocPrinterA(hprinter: super::super::Foundation::HANDLE, level: u32, pdocinfo: *const DOC_INFO_1A) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn StartDocPrinterW(hprinter: super::super::Foundation::HANDLE, level: u32, pdocinfo: *const DOC_INFO_1W) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn StartPagePrinter(hprinter: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn UnRegisterForPrintAsyncNotifications(param0: super::super::Foundation::HANDLE) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn UpdatePrintDeviceObject(hprinter: super::super::Foundation::HANDLE, hdeviceobject: super::super::Foundation::HANDLE) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn UploadPrinterDriverPackageA(pszserver: super::super::Foundation::PSTR, pszinfpath: super::super::Foundation::PSTR, pszenvironment: super::super::Foundation::PSTR, dwflags: u32, hwnd: super::super::Foundation::HWND, pszdestinfpath: super::super::Foundation::PSTR, pcchdestinfpath: *mut u32) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn UploadPrinterDriverPackageW(pszserver: super::super::Foundation::PWSTR, pszinfpath: super::super::Foundation::PWSTR, pszenvironment: super::super::Foundation::PWSTR, dwflags: u32, hwnd: super::super::Foundation::HWND, pszdestinfpath: super::super::Foundation::PWSTR, pcchdestinfpath: *mut u32) -> ::windows_sys::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub fn WaitForPrinterChange(hprinter: super::super::Foundation::HANDLE, flags: u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub fn WritePrinter(hprinter: super::super::Foundation::HANDLE, pbuf: *const ::core::ffi::c_void, cbbuf: u32, pcwritten: *mut u32) -> super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub fn XcvDataW(hxcv: super::super::Foundation::HANDLE, pszdataname: super::super::Foundation::PWSTR, pinputdata: *const u8, cbinputdata: u32, poutputdata: *mut u8, cboutputdata: u32, pcboutputneeded: *mut u32, pdwstatus: *mut u32) -> super::super::Foundation::BOOL;
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct ADDJOB_INFO_1A {
pub Path: super::super::Foundation::PSTR,
pub JobId: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for ADDJOB_INFO_1A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for ADDJOB_INFO_1A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct ADDJOB_INFO_1W {
pub Path: super::super::Foundation::PWSTR,
pub JobId: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for ADDJOB_INFO_1W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for ADDJOB_INFO_1W {
fn clone(&self) -> Self {
*self
}
}
pub const APD_COPY_ALL_FILES: u32 = 4u32;
pub const APD_COPY_FROM_DIRECTORY: u32 = 16u32;
pub const APD_COPY_NEW_FILES: u32 = 8u32;
pub const APD_STRICT_DOWNGRADE: u32 = 2u32;
pub const APD_STRICT_UPGRADE: u32 = 1u32;
pub const APPLYCPSUI_NO_NEWDEF: u32 = 1u32;
pub const APPLYCPSUI_OK_CANCEL_BUTTON: u32 = 2u32;
#[repr(C)]
pub struct ATTRIBUTE_INFO_1 {
pub dwJobNumberOfPagesPerSide: u32,
pub dwDrvNumberOfPagesPerSide: u32,
pub dwNupBorderFlags: u32,
pub dwJobPageOrderFlags: u32,
pub dwDrvPageOrderFlags: u32,
pub dwJobNumberOfCopies: u32,
pub dwDrvNumberOfCopies: u32,
}
impl ::core::marker::Copy for ATTRIBUTE_INFO_1 {}
impl ::core::clone::Clone for ATTRIBUTE_INFO_1 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct ATTRIBUTE_INFO_2 {
pub dwJobNumberOfPagesPerSide: u32,
pub dwDrvNumberOfPagesPerSide: u32,
pub dwNupBorderFlags: u32,
pub dwJobPageOrderFlags: u32,
pub dwDrvPageOrderFlags: u32,
pub dwJobNumberOfCopies: u32,
pub dwDrvNumberOfCopies: u32,
pub dwColorOptimization: u32,
}
impl ::core::marker::Copy for ATTRIBUTE_INFO_2 {}
impl ::core::clone::Clone for ATTRIBUTE_INFO_2 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct ATTRIBUTE_INFO_3 {
pub dwJobNumberOfPagesPerSide: u32,
pub dwDrvNumberOfPagesPerSide: u32,
pub dwNupBorderFlags: u32,
pub dwJobPageOrderFlags: u32,
pub dwDrvPageOrderFlags: u32,
pub dwJobNumberOfCopies: u32,
pub dwDrvNumberOfCopies: u32,
pub dwColorOptimization: u32,
pub dmPrintQuality: i16,
pub dmYResolution: i16,
}
impl ::core::marker::Copy for ATTRIBUTE_INFO_3 {}
impl ::core::clone::Clone for ATTRIBUTE_INFO_3 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct ATTRIBUTE_INFO_4 {
pub dwJobNumberOfPagesPerSide: u32,
pub dwDrvNumberOfPagesPerSide: u32,
pub dwNupBorderFlags: u32,
pub dwJobPageOrderFlags: u32,
pub dwDrvPageOrderFlags: u32,
pub dwJobNumberOfCopies: u32,
pub dwDrvNumberOfCopies: u32,
pub dwColorOptimization: u32,
pub dmPrintQuality: i16,
pub dmYResolution: i16,
pub dwDuplexFlags: u32,
pub dwNupDirection: u32,
pub dwBookletFlags: u32,
pub dwScalingPercentX: u32,
pub dwScalingPercentY: u32,
}
impl ::core::marker::Copy for ATTRIBUTE_INFO_4 {}
impl ::core::clone::Clone for ATTRIBUTE_INFO_4 {
fn clone(&self) -> Self {
*self
}
}
pub const BIDI_ACCESS_ADMINISTRATOR: u32 = 1u32;
pub const BIDI_ACCESS_USER: u32 = 2u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct BIDI_DATA {
pub dwBidiType: u32,
pub u: BIDI_DATA_0,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for BIDI_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for BIDI_DATA {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub union BIDI_DATA_0 {
pub bData: super::super::Foundation::BOOL,
pub iData: i32,
pub sData: super::super::Foundation::PWSTR,
pub fData: f32,
pub biData: BINARY_CONTAINER,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for BIDI_DATA_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for BIDI_DATA_0 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct BIDI_REQUEST_CONTAINER {
pub Version: u32,
pub Flags: u32,
pub Count: u32,
pub aData: [BIDI_REQUEST_DATA; 1],
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for BIDI_REQUEST_CONTAINER {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for BIDI_REQUEST_CONTAINER {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct BIDI_REQUEST_DATA {
pub dwReqNumber: u32,
pub pSchema: super::super::Foundation::PWSTR,
pub data: BIDI_DATA,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for BIDI_REQUEST_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for BIDI_REQUEST_DATA {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct BIDI_RESPONSE_CONTAINER {
pub Version: u32,
pub Flags: u32,
pub Count: u32,
pub aData: [BIDI_RESPONSE_DATA; 1],
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for BIDI_RESPONSE_CONTAINER {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for BIDI_RESPONSE_CONTAINER {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct BIDI_RESPONSE_DATA {
pub dwResult: u32,
pub dwReqNumber: u32,
pub pSchema: super::super::Foundation::PWSTR,
pub data: BIDI_DATA,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for BIDI_RESPONSE_DATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for BIDI_RESPONSE_DATA {
fn clone(&self) -> Self {
*self
}
}
pub type BIDI_TYPE = i32;
pub const BIDI_NULL: BIDI_TYPE = 0i32;
pub const BIDI_INT: BIDI_TYPE = 1i32;
pub const BIDI_FLOAT: BIDI_TYPE = 2i32;
pub const BIDI_BOOL: BIDI_TYPE = 3i32;
pub const BIDI_STRING: BIDI_TYPE = 4i32;
pub const BIDI_TEXT: BIDI_TYPE = 5i32;
pub const BIDI_ENUM: BIDI_TYPE = 6i32;
pub const BIDI_BLOB: BIDI_TYPE = 7i32;
#[repr(C)]
pub struct BINARY_CONTAINER {
pub cbBuf: u32,
pub pData: *mut u8,
}
impl ::core::marker::Copy for BINARY_CONTAINER {}
impl ::core::clone::Clone for BINARY_CONTAINER {
fn clone(&self) -> Self {
*self
}
}
pub const BOOKLET_EDGE_LEFT: u32 = 0u32;
pub const BOOKLET_EDGE_RIGHT: u32 = 1u32;
pub const BOOKLET_PRINT: u32 = 2u32;
pub const BORDER_PRINT: u32 = 0u32;
pub const BidiRequest: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
data1: 3105237539,
data2: 17913,
data3: 18380,
data4: [128, 245, 254, 15, 233, 185, 225, 162],
};
pub const BidiRequestContainer: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
data1: 4233857572,
data2: 56069,
data3: 18945,
data4: [131, 136, 34, 237, 246, 194, 187, 186],
};
pub const BidiSpl: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 711017024, data2: 42181, data3: 19507, data4: [189, 135, 27, 199, 9, 51, 22, 57] };
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct BranchOfficeJobData {
pub eEventType: EBranchOfficeJobEventType,
pub JobId: u32,
pub JobInfo: BranchOfficeJobData_0,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for BranchOfficeJobData {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for BranchOfficeJobData {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub union BranchOfficeJobData_0 {
pub LogJobPrinted: BranchOfficeJobDataPrinted,
pub LogJobRendered: BranchOfficeJobDataRendered,
pub LogJobError: BranchOfficeJobDataError,
pub LogPipelineFailed: BranchOfficeJobDataPipelineFailed,
pub LogOfflineFileFull: BranchOfficeLogOfflineFileFull,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for BranchOfficeJobData_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for BranchOfficeJobData_0 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct BranchOfficeJobDataContainer {
pub cJobDataEntries: u32,
pub JobData: [BranchOfficeJobData; 1],
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for BranchOfficeJobDataContainer {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for BranchOfficeJobDataContainer {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct BranchOfficeJobDataError {
pub LastError: u32,
pub pDocumentName: super::super::Foundation::PWSTR,
pub pUserName: super::super::Foundation::PWSTR,
pub pPrinterName: super::super::Foundation::PWSTR,
pub pDataType: super::super::Foundation::PWSTR,
pub TotalSize: i64,
pub PrintedSize: i64,
pub TotalPages: u32,
pub PrintedPages: u32,
pub pMachineName: super::super::Foundation::PWSTR,
pub pJobError: super::super::Foundation::PWSTR,
pub pErrorDescription: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for BranchOfficeJobDataError {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for BranchOfficeJobDataError {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct BranchOfficeJobDataPipelineFailed {
pub pDocumentName: super::super::Foundation::PWSTR,
pub pPrinterName: super::super::Foundation::PWSTR,
pub pExtraErrorInfo: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for BranchOfficeJobDataPipelineFailed {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for BranchOfficeJobDataPipelineFailed {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct BranchOfficeJobDataPrinted {
pub Status: u32,
pub pDocumentName: super::super::Foundation::PWSTR,
pub pUserName: super::super::Foundation::PWSTR,
pub pMachineName: super::super::Foundation::PWSTR,
pub pPrinterName: super::super::Foundation::PWSTR,
pub pPortName: super::super::Foundation::PWSTR,
pub Size: i64,
pub TotalPages: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for BranchOfficeJobDataPrinted {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for BranchOfficeJobDataPrinted {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct BranchOfficeJobDataRendered {
pub Size: i64,
pub ICMMethod: u32,
pub Color: i16,
pub PrintQuality: i16,
pub YResolution: i16,
pub Copies: i16,
pub TTOption: i16,
}
impl ::core::marker::Copy for BranchOfficeJobDataRendered {}
impl ::core::clone::Clone for BranchOfficeJobDataRendered {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct BranchOfficeLogOfflineFileFull {
pub pMachineName: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for BranchOfficeLogOfflineFileFull {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for BranchOfficeLogOfflineFileFull {
fn clone(&self) -> Self {
*self
}
}
pub const CC_BIG5: i32 = -10i32;
pub const CC_CP437: i32 = -1i32;
pub const CC_CP850: i32 = -2i32;
pub const CC_CP863: i32 = -3i32;
pub const CC_DEFAULT: u32 = 0u32;
pub const CC_GB2312: i32 = -16i32;
pub const CC_ISC: i32 = -11i32;
pub const CC_JIS: i32 = -12i32;
pub const CC_JIS_ANK: i32 = -13i32;
pub const CC_NOPRECNV: u32 = 65535u32;
pub const CC_NS86: i32 = -14i32;
pub const CC_SJIS: i32 = -17i32;
pub const CC_TCA: i32 = -15i32;
pub const CC_WANSUNG: i32 = -18i32;
pub const CDM_CONVERT: u32 = 1u32;
pub const CDM_CONVERT351: u32 = 2u32;
pub const CDM_DRIVER_DEFAULT: u32 = 4u32;
pub const CHKBOXS_FALSE_PDATA: u32 = 3u32;
pub const CHKBOXS_FALSE_TRUE: u32 = 0u32;
pub const CHKBOXS_NONE_PDATA: u32 = 6u32;
pub const CHKBOXS_NO_PDATA: u32 = 4u32;
pub const CHKBOXS_NO_YES: u32 = 1u32;
pub const CHKBOXS_OFF_ON: u32 = 2u32;
pub const CHKBOXS_OFF_PDATA: u32 = 5u32;
pub const CLSID_OEMPTPROVIDER: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
data1: 2440181906,
data2: 17874,
data3: 18658,
data4: [158, 201, 86, 35, 121, 218, 249, 146],
};
pub const CLSID_OEMRENDER: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1835712294, data2: 40760, data3: 4561, data4: [136, 42, 0, 192, 79, 185, 97, 236] };
pub const CLSID_OEMUI: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 2882437335, data2: 40774, data3: 4561, data4: [136, 42, 0, 192, 79, 185, 97, 236] };
pub const CLSID_OEMUIMXDC: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1309950720, data2: 23363, data3: 17032, data4: [147, 42, 94, 77, 214, 216, 43, 237] };
pub const CLSID_PTPROVIDER: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
data1: 1185682715,
data2: 33936,
data3: 17713,
data4: [150, 204, 85, 191, 43, 241, 158, 17],
};
pub const CLSID_XPSRASTERIZER_FACTORY: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
data1: 1346271679,
data2: 7433,
data3: 18276,
data4: [157, 114, 30, 176, 198, 89, 103, 198],
};
pub const COLOR_OPTIMIZATION: u32 = 1u32;
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub struct COMPROPSHEETUI {
pub cbSize: u16,
pub Flags: u16,
pub hInstCaller: super::super::Foundation::HINSTANCE,
pub pCallerName: *mut i8,
pub UserData: usize,
pub pHelpFile: *mut i8,
pub pfnCallBack: _CPSUICALLBACK,
pub pOptItem: *mut OPTITEM,
pub pDlgPage: *mut DLGPAGE,
pub cOptItem: u16,
pub cDlgPage: u16,
pub IconID: usize,
pub pOptItemName: *mut i8,
pub CallerVersion: u16,
pub OptItemVersion: u16,
pub dwReserved: [usize; 4],
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for COMPROPSHEETUI {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for COMPROPSHEETUI {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct CONFIG_INFO_DATA_1 {
pub Reserved: [u8; 128],
pub dwVersion: u32,
}
impl ::core::marker::Copy for CONFIG_INFO_DATA_1 {}
impl ::core::clone::Clone for CONFIG_INFO_DATA_1 {
fn clone(&self) -> Self {
*self
}
}
pub const COPYFILE_EVENT_ADD_PRINTER_CONNECTION: u32 = 3u32;
pub const COPYFILE_EVENT_DELETE_PRINTER: u32 = 2u32;
pub const COPYFILE_EVENT_DELETE_PRINTER_CONNECTION: u32 = 4u32;
pub const COPYFILE_EVENT_FILES_CHANGED: u32 = 5u32;
pub const COPYFILE_EVENT_SET_PRINTER_DATAEX: u32 = 1u32;
pub const COPYFILE_FLAG_CLIENT_SPOOLER: u32 = 1u32;
pub const COPYFILE_FLAG_SERVER_SPOOLER: u32 = 2u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct CORE_PRINTER_DRIVERA {
pub CoreDriverGUID: ::windows_sys::core::GUID,
pub ftDriverDate: super::super::Foundation::FILETIME,
pub dwlDriverVersion: u64,
pub szPackageID: [super::super::Foundation::CHAR; 260],
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for CORE_PRINTER_DRIVERA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for CORE_PRINTER_DRIVERA {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct CORE_PRINTER_DRIVERW {
pub CoreDriverGUID: ::windows_sys::core::GUID,
pub ftDriverDate: super::super::Foundation::FILETIME,
pub dwlDriverVersion: u64,
pub szPackageID: [u16; 260],
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for CORE_PRINTER_DRIVERW {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for CORE_PRINTER_DRIVERW {
fn clone(&self) -> Self {
*self
}
}
pub const CPSFUNC_ADD_HPROPSHEETPAGE: u32 = 0u32;
pub const CPSFUNC_ADD_PCOMPROPSHEETUI: u32 = 3u32;
pub const CPSFUNC_ADD_PCOMPROPSHEETUIA: u32 = 2u32;
pub const CPSFUNC_ADD_PCOMPROPSHEETUIW: u32 = 3u32;
pub const CPSFUNC_ADD_PFNPROPSHEETUI: u32 = 5u32;
pub const CPSFUNC_ADD_PFNPROPSHEETUIA: u32 = 4u32;
pub const CPSFUNC_ADD_PFNPROPSHEETUIW: u32 = 5u32;
pub const CPSFUNC_ADD_PROPSHEETPAGE: u32 = 1u32;
pub const CPSFUNC_ADD_PROPSHEETPAGEA: u32 = 15u32;
pub const CPSFUNC_ADD_PROPSHEETPAGEW: u32 = 1u32;
pub const CPSFUNC_DELETE_HCOMPROPSHEET: u32 = 6u32;
pub const CPSFUNC_DO_APPLY_CPSUI: u32 = 25u32;
pub const CPSFUNC_GET_HPSUIPAGES: u32 = 10u32;
pub const CPSFUNC_GET_PAGECOUNT: u32 = 8u32;
pub const CPSFUNC_GET_PFNPROPSHEETUI_ICON: u32 = 14u32;
pub const CPSFUNC_IGNORE_CPSUI_PSN_APPLY: u32 = 24u32;
pub const CPSFUNC_INSERT_PSUIPAGE: u32 = 17u32;
pub const CPSFUNC_INSERT_PSUIPAGEA: u32 = 16u32;
pub const CPSFUNC_INSERT_PSUIPAGEW: u32 = 17u32;
pub const CPSFUNC_LOAD_CPSUI_ICON: u32 = 13u32;
pub const CPSFUNC_LOAD_CPSUI_STRING: u32 = 12u32;
pub const CPSFUNC_LOAD_CPSUI_STRINGA: u32 = 11u32;
pub const CPSFUNC_LOAD_CPSUI_STRINGW: u32 = 12u32;
pub const CPSFUNC_QUERY_DATABLOCK: u32 = 22u32;
pub const CPSFUNC_SET_DATABLOCK: u32 = 21u32;
pub const CPSFUNC_SET_DMPUB_HIDEBITS: u32 = 23u32;
pub const CPSFUNC_SET_FUSION_CONTEXT: u32 = 26u32;
pub const CPSFUNC_SET_HSTARTPAGE: u32 = 7u32;
pub const CPSFUNC_SET_PSUIPAGE_ICON: u32 = 20u32;
pub const CPSFUNC_SET_PSUIPAGE_TITLE: u32 = 19u32;
pub const CPSFUNC_SET_PSUIPAGE_TITLEA: u32 = 18u32;
pub const CPSFUNC_SET_PSUIPAGE_TITLEW: u32 = 19u32;
pub const CPSFUNC_SET_RESULT: u32 = 9u32;
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub struct CPSUICBPARAM {
pub cbSize: u16,
pub Reason: u16,
pub hDlg: super::super::Foundation::HWND,
pub pOptItem: *mut OPTITEM,
pub cOptItem: u16,
pub Flags: u16,
pub pCurItem: *mut OPTITEM,
pub Anonymous: CPSUICBPARAM_0,
pub UserData: usize,
pub Result: usize,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for CPSUICBPARAM {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for CPSUICBPARAM {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub union CPSUICBPARAM_0 {
pub OldSel: i32,
pub pOldSel: *mut i8,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for CPSUICBPARAM_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for CPSUICBPARAM_0 {
fn clone(&self) -> Self {
*self
}
}
pub const CPSUICB_ACTION_ITEMS_APPLIED: u32 = 4u32;
pub const CPSUICB_ACTION_NONE: u32 = 0u32;
pub const CPSUICB_ACTION_NO_APPLY_EXIT: u32 = 3u32;
pub const CPSUICB_ACTION_OPTIF_CHANGED: u32 = 1u32;
pub const CPSUICB_ACTION_REINIT_ITEMS: u32 = 2u32;
pub const CPSUICB_REASON_ABOUT: u32 = 9u32;
pub const CPSUICB_REASON_APPLYNOW: u32 = 6u32;
pub const CPSUICB_REASON_DLGPROC: u32 = 3u32;
pub const CPSUICB_REASON_ECB_CHANGED: u32 = 2u32;
pub const CPSUICB_REASON_EXTPUSH: u32 = 5u32;
pub const CPSUICB_REASON_ITEMS_REVERTED: u32 = 8u32;
pub const CPSUICB_REASON_KILLACTIVE: u32 = 11u32;
pub const CPSUICB_REASON_OPTITEM_SETFOCUS: u32 = 7u32;
pub const CPSUICB_REASON_PUSHBUTTON: u32 = 1u32;
pub const CPSUICB_REASON_SEL_CHANGED: u32 = 0u32;
pub const CPSUICB_REASON_SETACTIVE: u32 = 10u32;
pub const CPSUICB_REASON_UNDO_CHANGES: u32 = 4u32;
#[repr(C)]
pub struct CPSUIDATABLOCK {
pub cbData: u32,
pub pbData: *mut u8,
}
impl ::core::marker::Copy for CPSUIDATABLOCK {}
impl ::core::clone::Clone for CPSUIDATABLOCK {
fn clone(&self) -> Self {
*self
}
}
pub const CPSUIF_ABOUT_CALLBACK: u32 = 4u32;
pub const CPSUIF_ICONID_AS_HICON: u32 = 2u32;
pub const CPSUIF_UPDATE_PERMISSION: u32 = 1u32;
pub const CPSUI_CANCEL: u32 = 0u32;
pub const CPSUI_OK: u32 = 1u32;
pub const CPSUI_REBOOTSYSTEM: u32 = 3u32;
pub const CPSUI_RESTARTWINDOWS: u32 = 2u32;
pub const CUSTOMPARAM_HEIGHT: u32 = 1u32;
pub const CUSTOMPARAM_HEIGHTOFFSET: u32 = 3u32;
pub const CUSTOMPARAM_MAX: u32 = 5u32;
pub const CUSTOMPARAM_ORIENTATION: u32 = 4u32;
pub const CUSTOMPARAM_WIDTH: u32 = 0u32;
pub const CUSTOMPARAM_WIDTHOFFSET: u32 = 2u32;
#[repr(C)]
pub struct CUSTOMSIZEPARAM {
pub dwOrder: i32,
pub lMinVal: i32,
pub lMaxVal: i32,
}
impl ::core::marker::Copy for CUSTOMSIZEPARAM {}
impl ::core::clone::Clone for CUSTOMSIZEPARAM {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DATATYPES_INFO_1A {
pub pName: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DATATYPES_INFO_1A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DATATYPES_INFO_1A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DATATYPES_INFO_1W {
pub pName: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DATATYPES_INFO_1W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DATATYPES_INFO_1W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct DATA_HEADER {
pub dwSignature: u32,
pub wSize: u16,
pub wDataID: u16,
pub dwDataSize: u32,
pub dwReserved: u32,
}
impl ::core::marker::Copy for DATA_HEADER {}
impl ::core::clone::Clone for DATA_HEADER {
fn clone(&self) -> Self {
*self
}
}
pub const DEF_PRIORITY: u32 = 1u32;
#[repr(C)]
pub struct DELETE_PORT_DATA_1 {
pub psztPortName: [u16; 64],
pub Reserved: [u8; 98],
pub dwVersion: u32,
pub dwReserved: u32,
}
impl ::core::marker::Copy for DELETE_PORT_DATA_1 {}
impl ::core::clone::Clone for DELETE_PORT_DATA_1 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEVICEPROPERTYHEADER {
pub cbSize: u16,
pub Flags: u16,
pub hPrinter: super::super::Foundation::HANDLE,
pub pszPrinterName: *mut i8,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DEVICEPROPERTYHEADER {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DEVICEPROPERTYHEADER {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub struct DEVQUERYPRINT_INFO {
pub cbSize: u16,
pub Level: u16,
pub hPrinter: super::super::Foundation::HANDLE,
pub pDevMode: *mut super::Gdi::DEVMODEA,
pub pszErrorStr: super::super::Foundation::PWSTR,
pub cchErrorStr: u32,
pub cchNeeded: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::marker::Copy for DEVQUERYPRINT_INFO {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for DEVQUERYPRINT_INFO {
fn clone(&self) -> Self {
*self
}
}
pub const DF_BKSP_OK: u32 = 64u32;
pub const DF_NOITALIC: u32 = 1u32;
pub const DF_NOUNDER: u32 = 2u32;
pub const DF_NO_BOLD: u32 = 8u32;
pub const DF_NO_DOUBLE_UNDERLINE: u32 = 16u32;
pub const DF_NO_STRIKETHRU: u32 = 32u32;
pub const DF_TYPE_CAPSL: u32 = 3u32;
pub const DF_TYPE_HPINTELLIFONT: u32 = 0u32;
pub const DF_TYPE_OEM1: u32 = 4u32;
pub const DF_TYPE_OEM2: u32 = 5u32;
pub const DF_TYPE_PST1: u32 = 2u32;
pub const DF_TYPE_TRUETYPE: u32 = 1u32;
pub const DF_XM_CR: u32 = 4u32;
pub const DISPID_PRINTEREXTENSION_CONTEXT: u32 = 11800u32;
pub const DISPID_PRINTEREXTENSION_CONTEXTCOLLECTION: u32 = 12100u32;
pub const DISPID_PRINTEREXTENSION_CONTEXTCOLLECTION_COUNT: u32 = 12101u32;
pub const DISPID_PRINTEREXTENSION_CONTEXTCOLLECTION_GETAT: u32 = 12102u32;
pub const DISPID_PRINTEREXTENSION_CONTEXT_DRIVERPROPERTIES: u32 = 11803u32;
pub const DISPID_PRINTEREXTENSION_CONTEXT_PRINTERQUEUE: u32 = 11801u32;
pub const DISPID_PRINTEREXTENSION_CONTEXT_PRINTSCHEMATICKET: u32 = 11802u32;
pub const DISPID_PRINTEREXTENSION_CONTEXT_USERPROPERTIES: u32 = 11804u32;
pub const DISPID_PRINTEREXTENSION_EVENT: u32 = 12200u32;
pub const DISPID_PRINTEREXTENSION_EVENTARGS: u32 = 12000u32;
pub const DISPID_PRINTEREXTENSION_EVENTARGS_BIDINOTIFICATION: u32 = 12001u32;
pub const DISPID_PRINTEREXTENSION_EVENTARGS_DETAILEDREASONID: u32 = 12005u32;
pub const DISPID_PRINTEREXTENSION_EVENTARGS_REASONID: u32 = 12002u32;
pub const DISPID_PRINTEREXTENSION_EVENTARGS_REQUEST: u32 = 12003u32;
pub const DISPID_PRINTEREXTENSION_EVENTARGS_SOURCEAPPLICATION: u32 = 12004u32;
pub const DISPID_PRINTEREXTENSION_EVENTARGS_WINDOWMODAL: u32 = 12006u32;
pub const DISPID_PRINTEREXTENSION_EVENTARGS_WINDOWPARENT: u32 = 12007u32;
pub const DISPID_PRINTEREXTENSION_EVENT_ONDRIVEREVENT: u32 = 12201u32;
pub const DISPID_PRINTEREXTENSION_EVENT_ONPRINTERQUEUESENUMERATED: u32 = 12202u32;
pub const DISPID_PRINTEREXTENSION_REQUEST: u32 = 11900u32;
pub const DISPID_PRINTEREXTENSION_REQUEST_CANCEL: u32 = 11901u32;
pub const DISPID_PRINTEREXTENSION_REQUEST_COMPLETE: u32 = 11902u32;
pub const DISPID_PRINTERPROPERTYBAG: u32 = 11400u32;
pub const DISPID_PRINTERPROPERTYBAG_GETBOOL: u32 = 11401u32;
pub const DISPID_PRINTERPROPERTYBAG_GETBYTES: u32 = 11407u32;
pub const DISPID_PRINTERPROPERTYBAG_GETINT32: u32 = 11403u32;
pub const DISPID_PRINTERPROPERTYBAG_GETREADSTREAM: u32 = 11409u32;
pub const DISPID_PRINTERPROPERTYBAG_GETSTRING: u32 = 11405u32;
pub const DISPID_PRINTERPROPERTYBAG_GETWRITESTREAM: u32 = 11410u32;
pub const DISPID_PRINTERPROPERTYBAG_SETBOOL: u32 = 11402u32;
pub const DISPID_PRINTERPROPERTYBAG_SETBYTES: u32 = 11408u32;
pub const DISPID_PRINTERPROPERTYBAG_SETINT32: u32 = 11404u32;
pub const DISPID_PRINTERPROPERTYBAG_SETSTRING: u32 = 11406u32;
pub const DISPID_PRINTERQUEUE: u32 = 11600u32;
pub const DISPID_PRINTERQUEUEEVENT: u32 = 11700u32;
pub const DISPID_PRINTERQUEUEEVENT_ONBIDIRESPONSERECEIVED: u32 = 11701u32;
pub const DISPID_PRINTERQUEUEVIEW: u32 = 12700u32;
pub const DISPID_PRINTERQUEUEVIEW_EVENT: u32 = 12800u32;
pub const DISPID_PRINTERQUEUEVIEW_EVENT_ONCHANGED: u32 = 12801u32;
pub const DISPID_PRINTERQUEUEVIEW_SETVIEWRANGE: u32 = 12701u32;
pub const DISPID_PRINTERQUEUE_GETPRINTERQUEUEVIEW: u32 = 11606u32;
pub const DISPID_PRINTERQUEUE_GETPROPERTIES: u32 = 11604u32;
pub const DISPID_PRINTERQUEUE_HANDLE: u32 = 11601u32;
pub const DISPID_PRINTERQUEUE_NAME: u32 = 11602u32;
pub const DISPID_PRINTERQUEUE_SENDBIDIQUERY: u32 = 11603u32;
pub const DISPID_PRINTERQUEUE_SENDBIDISETREQUESTASYNC: u32 = 11605u32;
pub const DISPID_PRINTERSCRIPTABLEPROPERTYBAG: u32 = 11500u32;
pub const DISPID_PRINTERSCRIPTABLEPROPERTYBAG_GETBOOL: u32 = 11501u32;
pub const DISPID_PRINTERSCRIPTABLEPROPERTYBAG_GETBYTES: u32 = 11507u32;
pub const DISPID_PRINTERSCRIPTABLEPROPERTYBAG_GETINT32: u32 = 11503u32;
pub const DISPID_PRINTERSCRIPTABLEPROPERTYBAG_GETREADSTREAM: u32 = 11509u32;
pub const DISPID_PRINTERSCRIPTABLEPROPERTYBAG_GETSTREAMASXML: u32 = 11411u32;
pub const DISPID_PRINTERSCRIPTABLEPROPERTYBAG_GETSTRING: u32 = 11505u32;
pub const DISPID_PRINTERSCRIPTABLEPROPERTYBAG_GETWRITESTREAM: u32 = 11510u32;
pub const DISPID_PRINTERSCRIPTABLEPROPERTYBAG_SETBOOL: u32 = 11502u32;
pub const DISPID_PRINTERSCRIPTABLEPROPERTYBAG_SETBYTES: u32 = 11508u32;
pub const DISPID_PRINTERSCRIPTABLEPROPERTYBAG_SETINT32: u32 = 11504u32;
pub const DISPID_PRINTERSCRIPTABLEPROPERTYBAG_SETSTRING: u32 = 11506u32;
pub const DISPID_PRINTERSCRIPTABLESEQUENTIALSTREAM: u32 = 11200u32;
pub const DISPID_PRINTERSCRIPTABLESEQUENTIALSTREAM_READ: u32 = 11201u32;
pub const DISPID_PRINTERSCRIPTABLESEQUENTIALSTREAM_WRITE: u32 = 11202u32;
pub const DISPID_PRINTERSCRIPTABLESTREAM: u32 = 11300u32;
pub const DISPID_PRINTERSCRIPTABLESTREAM_COMMIT: u32 = 11301u32;
pub const DISPID_PRINTERSCRIPTABLESTREAM_SEEK: u32 = 11302u32;
pub const DISPID_PRINTERSCRIPTABLESTREAM_SETSIZE: u32 = 11303u32;
pub const DISPID_PRINTERSCRIPTCONTEXT: u32 = 12300u32;
pub const DISPID_PRINTERSCRIPTCONTEXT_DRIVERPROPERTIES: u32 = 12301u32;
pub const DISPID_PRINTERSCRIPTCONTEXT_QUEUEPROPERTIES: u32 = 12302u32;
pub const DISPID_PRINTERSCRIPTCONTEXT_USERPROPERTIES: u32 = 12303u32;
pub const DISPID_PRINTJOBCOLLECTION: u32 = 12600u32;
pub const DISPID_PRINTJOBCOLLECTION_COUNT: u32 = 12601u32;
pub const DISPID_PRINTJOBCOLLECTION_GETAT: u32 = 12602u32;
pub const DISPID_PRINTSCHEMA_ASYNCOPERATION: u32 = 10900u32;
pub const DISPID_PRINTSCHEMA_ASYNCOPERATIONEVENT: u32 = 11100u32;
pub const DISPID_PRINTSCHEMA_ASYNCOPERATIONEVENT_COMPLETED: u32 = 11101u32;
pub const DISPID_PRINTSCHEMA_ASYNCOPERATION_CANCEL: u32 = 10902u32;
pub const DISPID_PRINTSCHEMA_ASYNCOPERATION_START: u32 = 10901u32;
pub const DISPID_PRINTSCHEMA_CAPABILITIES: u32 = 10800u32;
pub const DISPID_PRINTSCHEMA_CAPABILITIES_GETFEATURE: u32 = 10802u32;
pub const DISPID_PRINTSCHEMA_CAPABILITIES_GETFEATURE_KEYNAME: u32 = 10801u32;
pub const DISPID_PRINTSCHEMA_CAPABILITIES_GETOPTIONS: u32 = 10807u32;
pub const DISPID_PRINTSCHEMA_CAPABILITIES_GETPARAMETERDEFINITION: u32 = 10808u32;
pub const DISPID_PRINTSCHEMA_CAPABILITIES_GETSELECTEDOPTION: u32 = 10806u32;
pub const DISPID_PRINTSCHEMA_CAPABILITIES_JOBCOPIESMAXVALUE: u32 = 10805u32;
pub const DISPID_PRINTSCHEMA_CAPABILITIES_JOBCOPIESMINVALUE: u32 = 10804u32;
pub const DISPID_PRINTSCHEMA_CAPABILITIES_PAGEIMAGEABLESIZE: u32 = 10803u32;
pub const DISPID_PRINTSCHEMA_DISPLAYABLEELEMENT: u32 = 10100u32;
pub const DISPID_PRINTSCHEMA_DISPLAYABLEELEMENT_DISPLAYNAME: u32 = 10101u32;
pub const DISPID_PRINTSCHEMA_ELEMENT: u32 = 10000u32;
pub const DISPID_PRINTSCHEMA_ELEMENT_NAME: u32 = 10002u32;
pub const DISPID_PRINTSCHEMA_ELEMENT_NAMESPACEURI: u32 = 10003u32;
pub const DISPID_PRINTSCHEMA_ELEMENT_XMLNODE: u32 = 10001u32;
pub const DISPID_PRINTSCHEMA_FEATURE: u32 = 10600u32;
pub const DISPID_PRINTSCHEMA_FEATURE_DISPLAYUI: u32 = 10604u32;
pub const DISPID_PRINTSCHEMA_FEATURE_GETOPTION: u32 = 10603u32;
pub const DISPID_PRINTSCHEMA_FEATURE_SELECTEDOPTION: u32 = 10601u32;
pub const DISPID_PRINTSCHEMA_FEATURE_SELECTIONTYPE: u32 = 10602u32;
pub const DISPID_PRINTSCHEMA_NUPOPTION: u32 = 10400u32;
pub const DISPID_PRINTSCHEMA_NUPOPTION_PAGESPERSHEET: u32 = 10401u32;
pub const DISPID_PRINTSCHEMA_OPTION: u32 = 10200u32;
pub const DISPID_PRINTSCHEMA_OPTIONCOLLECTION: u32 = 10500u32;
pub const DISPID_PRINTSCHEMA_OPTIONCOLLECTION_COUNT: u32 = 10501u32;
pub const DISPID_PRINTSCHEMA_OPTIONCOLLECTION_GETAT: u32 = 10502u32;
pub const DISPID_PRINTSCHEMA_OPTION_CONSTRAINED: u32 = 10202u32;
pub const DISPID_PRINTSCHEMA_OPTION_GETPROPERTYVALUE: u32 = 10203u32;
pub const DISPID_PRINTSCHEMA_OPTION_SELECTED: u32 = 10201u32;
pub const DISPID_PRINTSCHEMA_PAGEIMAGEABLESIZE: u32 = 10700u32;
pub const DISPID_PRINTSCHEMA_PAGEIMAGEABLESIZE_EXTENT_HEIGHT: u32 = 10706u32;
pub const DISPID_PRINTSCHEMA_PAGEIMAGEABLESIZE_EXTENT_WIDTH: u32 = 10705u32;
pub const DISPID_PRINTSCHEMA_PAGEIMAGEABLESIZE_IMAGEABLE_HEIGHT: u32 = 10702u32;
pub const DISPID_PRINTSCHEMA_PAGEIMAGEABLESIZE_IMAGEABLE_WIDTH: u32 = 10701u32;
pub const DISPID_PRINTSCHEMA_PAGEIMAGEABLESIZE_ORIGIN_HEIGHT: u32 = 10704u32;
pub const DISPID_PRINTSCHEMA_PAGEIMAGEABLESIZE_ORIGIN_WIDTH: u32 = 10703u32;
pub const DISPID_PRINTSCHEMA_PAGEMEDIASIZEOPTION: u32 = 10300u32;
pub const DISPID_PRINTSCHEMA_PAGEMEDIASIZEOPTION_HEIGHT: u32 = 10302u32;
pub const DISPID_PRINTSCHEMA_PAGEMEDIASIZEOPTION_WIDTH: u32 = 10301u32;
pub const DISPID_PRINTSCHEMA_PARAMETERDEFINITION: u32 = 12500u32;
pub const DISPID_PRINTSCHEMA_PARAMETERDEFINITION_DATATYPE: u32 = 12503u32;
pub const DISPID_PRINTSCHEMA_PARAMETERDEFINITION_RANGEMAX: u32 = 12505u32;
pub const DISPID_PRINTSCHEMA_PARAMETERDEFINITION_RANGEMIN: u32 = 12504u32;
pub const DISPID_PRINTSCHEMA_PARAMETERDEFINITION_UNITTYPE: u32 = 12502u32;
pub const DISPID_PRINTSCHEMA_PARAMETERDEFINITION_USERINPUTREQUIRED: u32 = 12501u32;
pub const DISPID_PRINTSCHEMA_PARAMETERINITIALIZER: u32 = 12400u32;
pub const DISPID_PRINTSCHEMA_PARAMETERINITIALIZER_VALUE: u32 = 12401u32;
pub const DISPID_PRINTSCHEMA_TICKET: u32 = 11000u32;
pub const DISPID_PRINTSCHEMA_TICKET_COMMITASYNC: u32 = 11004u32;
pub const DISPID_PRINTSCHEMA_TICKET_GETCAPABILITIES: u32 = 11006u32;
pub const DISPID_PRINTSCHEMA_TICKET_GETFEATURE: u32 = 11002u32;
pub const DISPID_PRINTSCHEMA_TICKET_GETFEATURE_KEYNAME: u32 = 11001u32;
pub const DISPID_PRINTSCHEMA_TICKET_GETPARAMETERINITIALIZER: u32 = 11008u32;
pub const DISPID_PRINTSCHEMA_TICKET_JOBCOPIESALLDOCUMENTS: u32 = 11007u32;
pub const DISPID_PRINTSCHEMA_TICKET_NOTIFYXMLCHANGED: u32 = 11005u32;
pub const DISPID_PRINTSCHEMA_TICKET_VALIDATEASYNC: u32 = 11003u32;
pub const DI_CHANNEL: u32 = 1u32;
pub const DI_MEMORYMAP_WRITE: u32 = 1u32;
pub const DI_READ_SPOOL_JOB: u32 = 3u32;
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub struct DLGPAGE {
pub cbSize: u16,
pub Flags: u16,
pub DlgProc: super::super::UI::WindowsAndMessaging::DLGPROC,
pub pTabName: *mut i8,
pub IconID: usize,
pub Anonymous: DLGPAGE_0,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for DLGPAGE {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for DLGPAGE {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub union DLGPAGE_0 {
pub DlgTemplateID: u16,
pub hDlgTemplate: super::super::Foundation::HANDLE,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for DLGPAGE_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for DLGPAGE_0 {
fn clone(&self) -> Self {
*self
}
}
pub const DMPUB_BOOKLET_EDGE: u32 = 21u32;
pub const DMPUB_COLOR: u32 = 6u32;
pub const DMPUB_COPIES_COLLATE: u32 = 3u32;
pub const DMPUB_DEFSOURCE: u32 = 4u32;
pub const DMPUB_DITHERTYPE: u32 = 13u32;
pub const DMPUB_DUPLEX: u32 = 7u32;
pub const DMPUB_FIRST: u32 = 1u32;
pub const DMPUB_FORMNAME: u32 = 9u32;
pub const DMPUB_ICMINTENT: u32 = 11u32;
pub const DMPUB_ICMMETHOD: u32 = 10u32;
pub const DMPUB_LAST: u32 = 21u32;
pub const DMPUB_MANUAL_DUPLEX: u32 = 19u32;
pub const DMPUB_MEDIATYPE: u32 = 12u32;
pub const DMPUB_NONE: u32 = 0u32;
pub const DMPUB_NUP: u32 = 16u32;
pub const DMPUB_NUP_DIRECTION: u32 = 18u32;
pub const DMPUB_OEM_GRAPHIC_ITEM: u32 = 98u32;
pub const DMPUB_OEM_PAPER_ITEM: u32 = 97u32;
pub const DMPUB_OEM_ROOT_ITEM: u32 = 99u32;
pub const DMPUB_ORIENTATION: u32 = 1u32;
pub const DMPUB_OUTPUTBIN: u32 = 14u32;
pub const DMPUB_PAGEORDER: u32 = 17u32;
pub const DMPUB_PRINTQUALITY: u32 = 5u32;
pub const DMPUB_QUALITY: u32 = 15u32;
pub const DMPUB_SCALE: u32 = 2u32;
pub const DMPUB_STAPLE: u32 = 20u32;
pub const DMPUB_TTOPTION: u32 = 8u32;
pub const DMPUB_USER: u32 = 100u32;
pub const DM_ADVANCED: u32 = 16u32;
pub const DM_INVALIDATE_DRIVER_CACHE: u32 = 536870912u32;
pub const DM_NOPERMISSION: u32 = 32u32;
pub const DM_PROMPT_NON_MODAL: u32 = 1073741824u32;
pub const DM_RESERVED: u32 = 2147483648u32;
pub const DM_USER_DEFAULT: u32 = 64u32;
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub struct DOCEVENT_CREATEDCPRE {
pub pszDriver: super::super::Foundation::PWSTR,
pub pszDevice: super::super::Foundation::PWSTR,
pub pdm: *mut super::Gdi::DEVMODEW,
pub bIC: super::super::Foundation::BOOL,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::marker::Copy for DOCEVENT_CREATEDCPRE {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for DOCEVENT_CREATEDCPRE {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct DOCEVENT_ESCAPE {
pub iEscape: i32,
pub cjInput: i32,
pub pvInData: *mut ::core::ffi::c_void,
}
impl ::core::marker::Copy for DOCEVENT_ESCAPE {}
impl ::core::clone::Clone for DOCEVENT_ESCAPE {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct DOCEVENT_FILTER {
pub cbSize: u32,
pub cElementsAllocated: u32,
pub cElementsNeeded: u32,
pub cElementsReturned: u32,
pub aDocEventCall: [u32; 1],
}
impl ::core::marker::Copy for DOCEVENT_FILTER {}
impl ::core::clone::Clone for DOCEVENT_FILTER {
fn clone(&self) -> Self {
*self
}
}
pub const DOCUMENTEVENT_ABORTDOC: u32 = 9u32;
pub const DOCUMENTEVENT_CREATEDCPOST: u32 = 2u32;
pub const DOCUMENTEVENT_CREATEDCPRE: u32 = 1u32;
pub const DOCUMENTEVENT_DELETEDC: u32 = 10u32;
pub const DOCUMENTEVENT_ENDDOC: u32 = 8u32;
pub const DOCUMENTEVENT_ENDDOCPOST: u32 = 12u32;
pub const DOCUMENTEVENT_ENDDOCPRE: u32 = 8u32;
pub const DOCUMENTEVENT_ENDPAGE: u32 = 7u32;
pub const DOCUMENTEVENT_ESCAPE: u32 = 11u32;
pub const DOCUMENTEVENT_FAILURE: i32 = -1i32;
pub const DOCUMENTEVENT_FIRST: u32 = 1u32;
pub const DOCUMENTEVENT_LAST: u32 = 15u32;
pub const DOCUMENTEVENT_QUERYFILTER: u32 = 14u32;
pub const DOCUMENTEVENT_RESETDCPOST: u32 = 4u32;
pub const DOCUMENTEVENT_RESETDCPRE: u32 = 3u32;
pub const DOCUMENTEVENT_SPOOLED: u32 = 65536u32;
pub const DOCUMENTEVENT_STARTDOC: u32 = 5u32;
pub const DOCUMENTEVENT_STARTDOCPOST: u32 = 13u32;
pub const DOCUMENTEVENT_STARTDOCPRE: u32 = 5u32;
pub const DOCUMENTEVENT_STARTPAGE: u32 = 6u32;
pub const DOCUMENTEVENT_SUCCESS: u32 = 1u32;
pub const DOCUMENTEVENT_UNSUPPORTED: u32 = 0u32;
pub const DOCUMENTEVENT_XPS_ADDFIXEDDOCUMENTPOST: u32 = 5u32;
pub const DOCUMENTEVENT_XPS_ADDFIXEDDOCUMENTPRE: u32 = 2u32;
pub const DOCUMENTEVENT_XPS_ADDFIXEDDOCUMENTPRINTTICKETPOST: u32 = 11u32;
pub const DOCUMENTEVENT_XPS_ADDFIXEDDOCUMENTPRINTTICKETPRE: u32 = 8u32;
pub const DOCUMENTEVENT_XPS_ADDFIXEDDOCUMENTSEQUENCEPOST: u32 = 13u32;
pub const DOCUMENTEVENT_XPS_ADDFIXEDDOCUMENTSEQUENCEPRE: u32 = 1u32;
pub const DOCUMENTEVENT_XPS_ADDFIXEDDOCUMENTSEQUENCEPRINTTICKETPOST: u32 = 12u32;
pub const DOCUMENTEVENT_XPS_ADDFIXEDDOCUMENTSEQUENCEPRINTTICKETPRE: u32 = 7u32;
pub const DOCUMENTEVENT_XPS_ADDFIXEDPAGEEPRE: u32 = 3u32;
pub const DOCUMENTEVENT_XPS_ADDFIXEDPAGEPOST: u32 = 4u32;
pub const DOCUMENTEVENT_XPS_ADDFIXEDPAGEPRINTTICKETPOST: u32 = 10u32;
pub const DOCUMENTEVENT_XPS_ADDFIXEDPAGEPRINTTICKETPRE: u32 = 9u32;
pub const DOCUMENTEVENT_XPS_CANCELJOB: u32 = 6u32;
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub struct DOCUMENTPROPERTYHEADER {
pub cbSize: u16,
pub Reserved: u16,
pub hPrinter: super::super::Foundation::HANDLE,
pub pszPrinterName: *mut i8,
pub pdmIn: *mut super::Gdi::DEVMODEA,
pub pdmOut: *mut super::Gdi::DEVMODEA,
pub cbOut: u32,
pub fMode: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::marker::Copy for DOCUMENTPROPERTYHEADER {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for DOCUMENTPROPERTYHEADER {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DOC_INFO_1A {
pub pDocName: super::super::Foundation::PSTR,
pub pOutputFile: super::super::Foundation::PSTR,
pub pDatatype: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DOC_INFO_1A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DOC_INFO_1A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DOC_INFO_1W {
pub pDocName: super::super::Foundation::PWSTR,
pub pOutputFile: super::super::Foundation::PWSTR,
pub pDatatype: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DOC_INFO_1W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DOC_INFO_1W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DOC_INFO_2A {
pub pDocName: super::super::Foundation::PSTR,
pub pOutputFile: super::super::Foundation::PSTR,
pub pDatatype: super::super::Foundation::PSTR,
pub dwMode: u32,
pub JobId: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DOC_INFO_2A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DOC_INFO_2A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DOC_INFO_2W {
pub pDocName: super::super::Foundation::PWSTR,
pub pOutputFile: super::super::Foundation::PWSTR,
pub pDatatype: super::super::Foundation::PWSTR,
pub dwMode: u32,
pub JobId: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DOC_INFO_2W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DOC_INFO_2W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DOC_INFO_3A {
pub pDocName: super::super::Foundation::PSTR,
pub pOutputFile: super::super::Foundation::PSTR,
pub pDatatype: super::super::Foundation::PSTR,
pub dwFlags: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DOC_INFO_3A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DOC_INFO_3A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DOC_INFO_3W {
pub pDocName: super::super::Foundation::PWSTR,
pub pOutputFile: super::super::Foundation::PWSTR,
pub pDatatype: super::super::Foundation::PWSTR,
pub dwFlags: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DOC_INFO_3W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DOC_INFO_3W {
fn clone(&self) -> Self {
*self
}
}
pub const DPD_DELETE_ALL_FILES: u32 = 4u32;
pub const DPD_DELETE_SPECIFIC_VERSION: u32 = 2u32;
pub const DPD_DELETE_UNUSED_FILES: u32 = 1u32;
pub const DPF_ICONID_AS_HICON: u32 = 1u32;
pub const DPF_USE_HDLGTEMPLATE: u32 = 2u32;
pub const DPS_NOPERMISSION: u32 = 1u32;
pub const DP_STD_DOCPROPPAGE1: u32 = 65533u32;
pub const DP_STD_DOCPROPPAGE2: u32 = 65534u32;
pub const DP_STD_RESERVED_START: u32 = 65520u32;
pub const DP_STD_TREEVIEWPAGE: u32 = 65535u32;
pub const DRIVER_EVENT_DELETE: u32 = 2u32;
pub const DRIVER_EVENT_INITIALIZE: u32 = 1u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_1A {
pub pName: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_1A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_1A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_1W {
pub pName: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_1W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_1W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_2A {
pub cVersion: u32,
pub pName: super::super::Foundation::PSTR,
pub pEnvironment: super::super::Foundation::PSTR,
pub pDriverPath: super::super::Foundation::PSTR,
pub pDataFile: super::super::Foundation::PSTR,
pub pConfigFile: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_2A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_2A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_2W {
pub cVersion: u32,
pub pName: super::super::Foundation::PWSTR,
pub pEnvironment: super::super::Foundation::PWSTR,
pub pDriverPath: super::super::Foundation::PWSTR,
pub pDataFile: super::super::Foundation::PWSTR,
pub pConfigFile: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_2W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_2W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_3A {
pub cVersion: u32,
pub pName: super::super::Foundation::PSTR,
pub pEnvironment: super::super::Foundation::PSTR,
pub pDriverPath: super::super::Foundation::PSTR,
pub pDataFile: super::super::Foundation::PSTR,
pub pConfigFile: super::super::Foundation::PSTR,
pub pHelpFile: super::super::Foundation::PSTR,
pub pDependentFiles: super::super::Foundation::PSTR,
pub pMonitorName: super::super::Foundation::PSTR,
pub pDefaultDataType: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_3A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_3A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_3W {
pub cVersion: u32,
pub pName: super::super::Foundation::PWSTR,
pub pEnvironment: super::super::Foundation::PWSTR,
pub pDriverPath: super::super::Foundation::PWSTR,
pub pDataFile: super::super::Foundation::PWSTR,
pub pConfigFile: super::super::Foundation::PWSTR,
pub pHelpFile: super::super::Foundation::PWSTR,
pub pDependentFiles: super::super::Foundation::PWSTR,
pub pMonitorName: super::super::Foundation::PWSTR,
pub pDefaultDataType: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_3W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_3W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_4A {
pub cVersion: u32,
pub pName: super::super::Foundation::PSTR,
pub pEnvironment: super::super::Foundation::PSTR,
pub pDriverPath: super::super::Foundation::PSTR,
pub pDataFile: super::super::Foundation::PSTR,
pub pConfigFile: super::super::Foundation::PSTR,
pub pHelpFile: super::super::Foundation::PSTR,
pub pDependentFiles: super::super::Foundation::PSTR,
pub pMonitorName: super::super::Foundation::PSTR,
pub pDefaultDataType: super::super::Foundation::PSTR,
pub pszzPreviousNames: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_4A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_4A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_4W {
pub cVersion: u32,
pub pName: super::super::Foundation::PWSTR,
pub pEnvironment: super::super::Foundation::PWSTR,
pub pDriverPath: super::super::Foundation::PWSTR,
pub pDataFile: super::super::Foundation::PWSTR,
pub pConfigFile: super::super::Foundation::PWSTR,
pub pHelpFile: super::super::Foundation::PWSTR,
pub pDependentFiles: super::super::Foundation::PWSTR,
pub pMonitorName: super::super::Foundation::PWSTR,
pub pDefaultDataType: super::super::Foundation::PWSTR,
pub pszzPreviousNames: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_4W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_4W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_5A {
pub cVersion: u32,
pub pName: super::super::Foundation::PSTR,
pub pEnvironment: super::super::Foundation::PSTR,
pub pDriverPath: super::super::Foundation::PSTR,
pub pDataFile: super::super::Foundation::PSTR,
pub pConfigFile: super::super::Foundation::PSTR,
pub dwDriverAttributes: u32,
pub dwConfigVersion: u32,
pub dwDriverVersion: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_5A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_5A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_5W {
pub cVersion: u32,
pub pName: super::super::Foundation::PWSTR,
pub pEnvironment: super::super::Foundation::PWSTR,
pub pDriverPath: super::super::Foundation::PWSTR,
pub pDataFile: super::super::Foundation::PWSTR,
pub pConfigFile: super::super::Foundation::PWSTR,
pub dwDriverAttributes: u32,
pub dwConfigVersion: u32,
pub dwDriverVersion: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_5W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_5W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_6A {
pub cVersion: u32,
pub pName: super::super::Foundation::PSTR,
pub pEnvironment: super::super::Foundation::PSTR,
pub pDriverPath: super::super::Foundation::PSTR,
pub pDataFile: super::super::Foundation::PSTR,
pub pConfigFile: super::super::Foundation::PSTR,
pub pHelpFile: super::super::Foundation::PSTR,
pub pDependentFiles: super::super::Foundation::PSTR,
pub pMonitorName: super::super::Foundation::PSTR,
pub pDefaultDataType: super::super::Foundation::PSTR,
pub pszzPreviousNames: super::super::Foundation::PSTR,
pub ftDriverDate: super::super::Foundation::FILETIME,
pub dwlDriverVersion: u64,
pub pszMfgName: super::super::Foundation::PSTR,
pub pszOEMUrl: super::super::Foundation::PSTR,
pub pszHardwareID: super::super::Foundation::PSTR,
pub pszProvider: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_6A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_6A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_6W {
pub cVersion: u32,
pub pName: super::super::Foundation::PWSTR,
pub pEnvironment: super::super::Foundation::PWSTR,
pub pDriverPath: super::super::Foundation::PWSTR,
pub pDataFile: super::super::Foundation::PWSTR,
pub pConfigFile: super::super::Foundation::PWSTR,
pub pHelpFile: super::super::Foundation::PWSTR,
pub pDependentFiles: super::super::Foundation::PWSTR,
pub pMonitorName: super::super::Foundation::PWSTR,
pub pDefaultDataType: super::super::Foundation::PWSTR,
pub pszzPreviousNames: super::super::Foundation::PWSTR,
pub ftDriverDate: super::super::Foundation::FILETIME,
pub dwlDriverVersion: u64,
pub pszMfgName: super::super::Foundation::PWSTR,
pub pszOEMUrl: super::super::Foundation::PWSTR,
pub pszHardwareID: super::super::Foundation::PWSTR,
pub pszProvider: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_6W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_6W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_8A {
pub cVersion: u32,
pub pName: super::super::Foundation::PSTR,
pub pEnvironment: super::super::Foundation::PSTR,
pub pDriverPath: super::super::Foundation::PSTR,
pub pDataFile: super::super::Foundation::PSTR,
pub pConfigFile: super::super::Foundation::PSTR,
pub pHelpFile: super::super::Foundation::PSTR,
pub pDependentFiles: super::super::Foundation::PSTR,
pub pMonitorName: super::super::Foundation::PSTR,
pub pDefaultDataType: super::super::Foundation::PSTR,
pub pszzPreviousNames: super::super::Foundation::PSTR,
pub ftDriverDate: super::super::Foundation::FILETIME,
pub dwlDriverVersion: u64,
pub pszMfgName: super::super::Foundation::PSTR,
pub pszOEMUrl: super::super::Foundation::PSTR,
pub pszHardwareID: super::super::Foundation::PSTR,
pub pszProvider: super::super::Foundation::PSTR,
pub pszPrintProcessor: super::super::Foundation::PSTR,
pub pszVendorSetup: super::super::Foundation::PSTR,
pub pszzColorProfiles: super::super::Foundation::PSTR,
pub pszInfPath: super::super::Foundation::PSTR,
pub dwPrinterDriverAttributes: u32,
pub pszzCoreDriverDependencies: super::super::Foundation::PSTR,
pub ftMinInboxDriverVerDate: super::super::Foundation::FILETIME,
pub dwlMinInboxDriverVerVersion: u64,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_8A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_8A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DRIVER_INFO_8W {
pub cVersion: u32,
pub pName: super::super::Foundation::PWSTR,
pub pEnvironment: super::super::Foundation::PWSTR,
pub pDriverPath: super::super::Foundation::PWSTR,
pub pDataFile: super::super::Foundation::PWSTR,
pub pConfigFile: super::super::Foundation::PWSTR,
pub pHelpFile: super::super::Foundation::PWSTR,
pub pDependentFiles: super::super::Foundation::PWSTR,
pub pMonitorName: super::super::Foundation::PWSTR,
pub pDefaultDataType: super::super::Foundation::PWSTR,
pub pszzPreviousNames: super::super::Foundation::PWSTR,
pub ftDriverDate: super::super::Foundation::FILETIME,
pub dwlDriverVersion: u64,
pub pszMfgName: super::super::Foundation::PWSTR,
pub pszOEMUrl: super::super::Foundation::PWSTR,
pub pszHardwareID: super::super::Foundation::PWSTR,
pub pszProvider: super::super::Foundation::PWSTR,
pub pszPrintProcessor: super::super::Foundation::PWSTR,
pub pszVendorSetup: super::super::Foundation::PWSTR,
pub pszzColorProfiles: super::super::Foundation::PWSTR,
pub pszInfPath: super::super::Foundation::PWSTR,
pub dwPrinterDriverAttributes: u32,
pub pszzCoreDriverDependencies: super::super::Foundation::PWSTR,
pub ftMinInboxDriverVerDate: super::super::Foundation::FILETIME,
pub dwlMinInboxDriverVerVersion: u64,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for DRIVER_INFO_8W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for DRIVER_INFO_8W {
fn clone(&self) -> Self {
*self
}
}
pub const DRIVER_KERNELMODE: u32 = 1u32;
#[repr(C)]
pub struct DRIVER_UPGRADE_INFO_1 {
pub pPrinterName: *mut i8,
pub pOldDriverDirectory: *mut i8,
}
impl ::core::marker::Copy for DRIVER_UPGRADE_INFO_1 {}
impl ::core::clone::Clone for DRIVER_UPGRADE_INFO_1 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct DRIVER_UPGRADE_INFO_2 {
pub pPrinterName: *mut i8,
pub pOldDriverDirectory: *mut i8,
pub cVersion: u32,
pub pName: *mut i8,
pub pEnvironment: *mut i8,
pub pDriverPath: *mut i8,
pub pDataFile: *mut i8,
pub pConfigFile: *mut i8,
pub pHelpFile: *mut i8,
pub pDependentFiles: *mut i8,
pub pMonitorName: *mut i8,
pub pDefaultDataType: *mut i8,
pub pszzPreviousNames: *mut i8,
}
impl ::core::marker::Copy for DRIVER_UPGRADE_INFO_2 {}
impl ::core::clone::Clone for DRIVER_UPGRADE_INFO_2 {
fn clone(&self) -> Self {
*self
}
}
pub const DRIVER_USERMODE: u32 = 2u32;
pub const DSPRINT_PENDING: u32 = 2147483648u32;
pub const DSPRINT_PUBLISH: u32 = 1u32;
pub const DSPRINT_REPUBLISH: u32 = 8u32;
pub const DSPRINT_UNPUBLISH: u32 = 4u32;
pub const DSPRINT_UPDATE: u32 = 2u32;
pub type EATTRIBUTE_DATATYPE = i32;
pub const kADT_UNKNOWN: EATTRIBUTE_DATATYPE = 0i32;
pub const kADT_BOOL: EATTRIBUTE_DATATYPE = 1i32;
pub const kADT_INT: EATTRIBUTE_DATATYPE = 2i32;
pub const kADT_LONG: EATTRIBUTE_DATATYPE = 3i32;
pub const kADT_DWORD: EATTRIBUTE_DATATYPE = 4i32;
pub const kADT_ASCII: EATTRIBUTE_DATATYPE = 5i32;
pub const kADT_UNICODE: EATTRIBUTE_DATATYPE = 6i32;
pub const kADT_BINARY: EATTRIBUTE_DATATYPE = 7i32;
pub const kADT_SIZE: EATTRIBUTE_DATATYPE = 8i32;
pub const kADT_RECT: EATTRIBUTE_DATATYPE = 9i32;
pub const kADT_CUSTOMSIZEPARAMS: EATTRIBUTE_DATATYPE = 10i32;
pub type EBranchOfficeJobEventType = i32;
pub const kInvalidJobState: EBranchOfficeJobEventType = 0i32;
pub const kLogJobPrinted: EBranchOfficeJobEventType = 1i32;
pub const kLogJobRendered: EBranchOfficeJobEventType = 2i32;
pub const kLogJobError: EBranchOfficeJobEventType = 3i32;
pub const kLogJobPipelineError: EBranchOfficeJobEventType = 4i32;
pub const kLogOfflineFileFull: EBranchOfficeJobEventType = 5i32;
pub const ECBF_CHECKNAME_AT_FRONT: u32 = 1u32;
pub const ECBF_CHECKNAME_ONLY: u32 = 128u32;
pub const ECBF_CHECKNAME_ONLY_ENABLED: u32 = 2u32;
pub const ECBF_ICONID_AS_HICON: u32 = 4u32;
pub const ECBF_MASK: u32 = 255u32;
pub const ECBF_OVERLAY_ECBICON_IF_CHECKED: u32 = 16u32;
pub const ECBF_OVERLAY_NO_ICON: u32 = 64u32;
pub const ECBF_OVERLAY_STOP_ICON: u32 = 32u32;
pub const ECBF_OVERLAY_WARNING_ICON: u32 = 8u32;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub type EMFPLAYPROC = ::core::option::Option<unsafe extern "system" fn(param0: super::Gdi::HDC, param1: i32, param2: super::super::Foundation::HANDLE) -> i32>;
pub const EMF_PP_COLOR_OPTIMIZATION: u32 = 1u32;
pub const EPF_ICONID_AS_HICON: u32 = 8u32;
pub const EPF_INCL_SETUP_TITLE: u32 = 2u32;
pub const EPF_MASK: u32 = 255u32;
pub const EPF_NO_DOT_DOT_DOT: u32 = 4u32;
pub const EPF_OVERLAY_NO_ICON: u32 = 64u32;
pub const EPF_OVERLAY_STOP_ICON: u32 = 32u32;
pub const EPF_OVERLAY_WARNING_ICON: u32 = 16u32;
pub const EPF_PUSH_TYPE_DLGPROC: u32 = 1u32;
pub const EPF_USE_HDLGTEMPLATE: u32 = 128u32;
pub type EPrintPropertyType = i32;
pub const kPropertyTypeString: EPrintPropertyType = 1i32;
pub const kPropertyTypeInt32: EPrintPropertyType = 2i32;
pub const kPropertyTypeInt64: EPrintPropertyType = 3i32;
pub const kPropertyTypeByte: EPrintPropertyType = 4i32;
pub const kPropertyTypeTime: EPrintPropertyType = 5i32;
pub const kPropertyTypeDevMode: EPrintPropertyType = 6i32;
pub const kPropertyTypeSD: EPrintPropertyType = 7i32;
pub const kPropertyTypeNotificationReply: EPrintPropertyType = 8i32;
pub const kPropertyTypeNotificationOptions: EPrintPropertyType = 9i32;
pub const kPropertyTypeBuffer: EPrintPropertyType = 10i32;
pub type EPrintXPSJobOperation = i32;
pub const kJobProduction: EPrintXPSJobOperation = 1i32;
pub const kJobConsumption: EPrintXPSJobOperation = 2i32;
pub type EPrintXPSJobProgress = i32;
pub const kAddingDocumentSequence: EPrintXPSJobProgress = 0i32;
pub const kDocumentSequenceAdded: EPrintXPSJobProgress = 1i32;
pub const kAddingFixedDocument: EPrintXPSJobProgress = 2i32;
pub const kFixedDocumentAdded: EPrintXPSJobProgress = 3i32;
pub const kAddingFixedPage: EPrintXPSJobProgress = 4i32;
pub const kFixedPageAdded: EPrintXPSJobProgress = 5i32;
pub const kResourceAdded: EPrintXPSJobProgress = 6i32;
pub const kFontAdded: EPrintXPSJobProgress = 7i32;
pub const kImageAdded: EPrintXPSJobProgress = 8i32;
pub const kXpsDocumentCommitted: EPrintXPSJobProgress = 9i32;
pub const ERROR_BIDI_DEVICE_CONFIG_UNCHANGED: u32 = 13014u32;
pub const ERROR_BIDI_DEVICE_OFFLINE: u32 = 13004u32;
pub const ERROR_BIDI_ERROR_BASE: u32 = 13000u32;
pub const ERROR_BIDI_GET_ARGUMENT_NOT_SUPPORTED: u32 = 13012u32;
pub const ERROR_BIDI_GET_MISSING_ARGUMENT: u32 = 13013u32;
pub const ERROR_BIDI_GET_REQUIRES_ARGUMENT: u32 = 13011u32;
pub const ERROR_BIDI_NO_BIDI_SCHEMA_EXTENSIONS: u32 = 13016u32;
pub const ERROR_BIDI_NO_LOCALIZED_RESOURCES: u32 = 13015u32;
pub const ERROR_BIDI_SCHEMA_NOT_SUPPORTED: u32 = 13005u32;
pub const ERROR_BIDI_SCHEMA_READ_ONLY: u32 = 13002u32;
pub const ERROR_BIDI_SCHEMA_WRITE_ONLY: u32 = 13010u32;
pub const ERROR_BIDI_SERVER_OFFLINE: u32 = 13003u32;
pub const ERROR_BIDI_SET_DIFFERENT_TYPE: u32 = 13006u32;
pub const ERROR_BIDI_SET_INVALID_SCHEMAPATH: u32 = 13008u32;
pub const ERROR_BIDI_SET_MULTIPLE_SCHEMAPATH: u32 = 13007u32;
pub const ERROR_BIDI_SET_UNKNOWN_FAILURE: u32 = 13009u32;
pub const ERROR_BIDI_STATUS_OK: u32 = 0u32;
pub const ERROR_BIDI_STATUS_WARNING: u32 = 13001u32;
pub const ERROR_BIDI_UNSUPPORTED_CLIENT_LANGUAGE: u32 = 13017u32;
pub const ERROR_BIDI_UNSUPPORTED_RESOURCE_FORMAT: u32 = 13018u32;
pub const ERR_CPSUI_ALLOCMEM_FAILED: i32 = -2i32;
pub const ERR_CPSUI_CREATEPROPPAGE_FAILED: i32 = -10i32;
pub const ERR_CPSUI_CREATE_IMAGELIST_FAILED: i32 = -33i32;
pub const ERR_CPSUI_CREATE_TRACKBAR_FAILED: i32 = -31i32;
pub const ERR_CPSUI_CREATE_UDARROW_FAILED: i32 = -32i32;
pub const ERR_CPSUI_DMCOPIES_USE_EXTPUSH: i32 = -43i32;
pub const ERR_CPSUI_FUNCTION_NOT_IMPLEMENTED: i32 = -9999i32;
pub const ERR_CPSUI_GETLASTERROR: i32 = -1i32;
pub const ERR_CPSUI_INTERNAL_ERROR: i32 = -10000i32;
pub const ERR_CPSUI_INVALID_DLGPAGEIDX: i32 = -16i32;
pub const ERR_CPSUI_INVALID_DLGPAGE_CBSIZE: i32 = -14i32;
pub const ERR_CPSUI_INVALID_DMPUBID: i32 = -29i32;
pub const ERR_CPSUI_INVALID_DMPUB_TVOT: i32 = -30i32;
pub const ERR_CPSUI_INVALID_ECB_CBSIZE: i32 = -26i32;
pub const ERR_CPSUI_INVALID_EDITBOX_BUF_SIZE: i32 = -25i32;
pub const ERR_CPSUI_INVALID_EDITBOX_PSEL: i32 = -24i32;
pub const ERR_CPSUI_INVALID_EXTPUSH_CBSIZE: i32 = -39i32;
pub const ERR_CPSUI_INVALID_LBCB_TYPE: i32 = -35i32;
pub const ERR_CPSUI_INVALID_LPARAM: i32 = -4i32;
pub const ERR_CPSUI_INVALID_OPTITEM_CBSIZE: i32 = -19i32;
pub const ERR_CPSUI_INVALID_OPTPARAM_CBSIZE: i32 = -23i32;
pub const ERR_CPSUI_INVALID_OPTTYPE_CBSIZE: i32 = -20i32;
pub const ERR_CPSUI_INVALID_OPTTYPE_COUNT: i32 = -21i32;
pub const ERR_CPSUI_INVALID_PDATA: i32 = -3i32;
pub const ERR_CPSUI_INVALID_PDLGPAGE: i32 = -13i32;
pub const ERR_CPSUI_INVALID_PUSHBUTTON_TYPE: i32 = -38i32;
pub const ERR_CPSUI_INVALID_TVOT_TYPE: i32 = -34i32;
pub const ERR_CPSUI_MORE_THAN_ONE_STDPAGE: i32 = -12i32;
pub const ERR_CPSUI_MORE_THAN_ONE_TVPAGE: i32 = -11i32;
pub const ERR_CPSUI_NO_EXTPUSH_DLGTEMPLATEID: i32 = -41i32;
pub const ERR_CPSUI_NO_PROPSHEETPAGE: i32 = -8i32;
pub const ERR_CPSUI_NULL_CALLERNAME: i32 = -6i32;
pub const ERR_CPSUI_NULL_ECB_PCHECKEDNAME: i32 = -28i32;
pub const ERR_CPSUI_NULL_ECB_PTITLE: i32 = -27i32;
pub const ERR_CPSUI_NULL_EXTPUSH_CALLBACK: i32 = -42i32;
pub const ERR_CPSUI_NULL_EXTPUSH_DLGPROC: i32 = -40i32;
pub const ERR_CPSUI_NULL_HINST: i32 = -5i32;
pub const ERR_CPSUI_NULL_OPTITEMNAME: i32 = -7i32;
pub const ERR_CPSUI_NULL_POPTITEM: i32 = -18i32;
pub const ERR_CPSUI_NULL_POPTPARAM: i32 = -22i32;
pub const ERR_CPSUI_SUBITEM_DIFF_DLGPAGEIDX: i32 = -17i32;
pub const ERR_CPSUI_SUBITEM_DIFF_OPTIF_HIDE: i32 = -36i32;
pub const ERR_CPSUI_TOO_MANY_DLGPAGES: i32 = -15i32;
pub const ERR_CPSUI_TOO_MANY_PROPSHEETPAGES: i32 = -9i32;
pub const ERR_CPSUI_ZERO_OPTITEM: i32 = -44i32;
#[repr(C)]
pub struct EXTCHKBOX {
pub cbSize: u16,
pub Flags: u16,
pub pTitle: *mut i8,
pub pSeparator: *mut i8,
pub pCheckedName: *mut i8,
pub IconID: usize,
pub wReserved: [u16; 4],
pub dwReserved: [usize; 2],
}
impl ::core::marker::Copy for EXTCHKBOX {}
impl ::core::clone::Clone for EXTCHKBOX {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub struct EXTPUSH {
pub cbSize: u16,
pub Flags: u16,
pub pTitle: *mut i8,
pub Anonymous1: EXTPUSH_0,
pub IconID: usize,
pub Anonymous2: EXTPUSH_1,
pub dwReserved: [usize; 3],
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for EXTPUSH {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for EXTPUSH {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub union EXTPUSH_0 {
pub DlgProc: super::super::UI::WindowsAndMessaging::DLGPROC,
pub pfnCallBack: super::super::Foundation::FARPROC,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for EXTPUSH_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for EXTPUSH_0 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub union EXTPUSH_1 {
pub DlgTemplateID: u16,
pub hDlgTemplate: super::super::Foundation::HANDLE,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for EXTPUSH_1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for EXTPUSH_1 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct EXTTEXTMETRIC {
pub emSize: i16,
pub emPointSize: i16,
pub emOrientation: i16,
pub emMasterHeight: i16,
pub emMinScale: i16,
pub emMaxScale: i16,
pub emMasterUnits: i16,
pub emCapHeight: i16,
pub emXHeight: i16,
pub emLowerCaseAscent: i16,
pub emLowerCaseDescent: i16,
pub emSlant: i16,
pub emSuperScript: i16,
pub emSubScript: i16,
pub emSuperScriptSize: i16,
pub emSubScriptSize: i16,
pub emUnderlineOffset: i16,
pub emUnderlineWidth: i16,
pub emDoubleUpperUnderlineOffset: i16,
pub emDoubleLowerUnderlineOffset: i16,
pub emDoubleUpperUnderlineWidth: i16,
pub emDoubleLowerUnderlineWidth: i16,
pub emStrikeOutOffset: i16,
pub emStrikeOutWidth: i16,
pub emKernPairs: u16,
pub emKernTracks: u16,
}
impl ::core::marker::Copy for EXTTEXTMETRIC {}
impl ::core::clone::Clone for EXTTEXTMETRIC {
fn clone(&self) -> Self {
*self
}
}
pub type EXpsCompressionOptions = i32;
pub const Compression_NotCompressed: EXpsCompressionOptions = 0i32;
pub const Compression_Normal: EXpsCompressionOptions = 1i32;
pub const Compression_Small: EXpsCompressionOptions = 2i32;
pub const Compression_Fast: EXpsCompressionOptions = 3i32;
pub type EXpsFontOptions = i32;
pub const Font_Normal: EXpsFontOptions = 0i32;
pub const Font_Obfusticate: EXpsFontOptions = 1i32;
pub type EXpsFontRestriction = i32;
pub const Xps_Restricted_Font_Installable: EXpsFontRestriction = 0i32;
pub const Xps_Restricted_Font_NoEmbedding: EXpsFontRestriction = 2i32;
pub const Xps_Restricted_Font_PreviewPrint: EXpsFontRestriction = 4i32;
pub const Xps_Restricted_Font_Editable: EXpsFontRestriction = 8i32;
pub type EXpsJobConsumption = i32;
pub const XpsJob_DocumentSequenceAdded: EXpsJobConsumption = 0i32;
pub const XpsJob_FixedDocumentAdded: EXpsJobConsumption = 1i32;
pub const XpsJob_FixedPageAdded: EXpsJobConsumption = 2i32;
pub const E_VERSION_NOT_SUPPORTED: u32 = 2147745793u32;
pub const FG_CANCHANGE: u32 = 128u32;
pub const FILL_WITH_DEFAULTS: u32 = 1u32;
pub const FMTID_PrinterPropertyBag: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
data1: 1979297226,
data2: 2429,
data3: 17859,
data4: [166, 228, 186, 178, 158, 39, 111, 62],
};
pub const FNT_INFO_CURRENTFONTID: u32 = 10u32;
pub const FNT_INFO_FONTBOLD: u32 = 6u32;
pub const FNT_INFO_FONTHEIGHT: u32 = 4u32;
pub const FNT_INFO_FONTITALIC: u32 = 7u32;
pub const FNT_INFO_FONTMAXWIDTH: u32 = 13u32;
pub const FNT_INFO_FONTSTRIKETHRU: u32 = 9u32;
pub const FNT_INFO_FONTUNDERLINE: u32 = 8u32;
pub const FNT_INFO_FONTWIDTH: u32 = 5u32;
pub const FNT_INFO_GRAYPERCENTAGE: u32 = 1u32;
pub const FNT_INFO_MAX: u32 = 14u32;
pub const FNT_INFO_NEXTFONTID: u32 = 2u32;
pub const FNT_INFO_NEXTGLYPH: u32 = 3u32;
pub const FNT_INFO_PRINTDIRINCCDEGREES: u32 = 0u32;
pub const FNT_INFO_TEXTXRES: u32 = 12u32;
pub const FNT_INFO_TEXTYRES: u32 = 11u32;
pub const FONT_DIR_SORTED: u32 = 1u32;
pub const FONT_FL_DEVICEFONT: u32 = 16u32;
pub const FONT_FL_GLYPHSET_GTT: u32 = 32u32;
pub const FONT_FL_GLYPHSET_RLE: u32 = 64u32;
pub const FONT_FL_IFI: u32 = 2u32;
pub const FONT_FL_PERMANENT_SF: u32 = 8u32;
pub const FONT_FL_RESERVED: u32 = 32768u32;
pub const FONT_FL_SOFTFONT: u32 = 4u32;
pub const FONT_FL_UFM: u32 = 1u32;
pub const FORM_BUILTIN: u32 = 1u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct FORM_INFO_1A {
pub Flags: u32,
pub pName: super::super::Foundation::PSTR,
pub Size: super::super::Foundation::SIZE,
pub ImageableArea: super::super::Foundation::RECTL,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for FORM_INFO_1A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for FORM_INFO_1A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct FORM_INFO_1W {
pub Flags: u32,
pub pName: super::super::Foundation::PWSTR,
pub Size: super::super::Foundation::SIZE,
pub ImageableArea: super::super::Foundation::RECTL,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for FORM_INFO_1W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for FORM_INFO_1W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct FORM_INFO_2A {
pub Flags: u32,
pub pName: super::super::Foundation::PSTR,
pub Size: super::super::Foundation::SIZE,
pub ImageableArea: super::super::Foundation::RECTL,
pub pKeyword: super::super::Foundation::PSTR,
pub StringType: u32,
pub pMuiDll: super::super::Foundation::PSTR,
pub dwResourceId: u32,
pub pDisplayName: super::super::Foundation::PSTR,
pub wLangId: u16,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for FORM_INFO_2A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for FORM_INFO_2A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct FORM_INFO_2W {
pub Flags: u32,
pub pName: super::super::Foundation::PWSTR,
pub Size: super::super::Foundation::SIZE,
pub ImageableArea: super::super::Foundation::RECTL,
pub pKeyword: super::super::Foundation::PSTR,
pub StringType: u32,
pub pMuiDll: super::super::Foundation::PWSTR,
pub dwResourceId: u32,
pub pDisplayName: super::super::Foundation::PWSTR,
pub wLangId: u16,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for FORM_INFO_2W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for FORM_INFO_2W {
fn clone(&self) -> Self {
*self
}
}
pub const FORM_PRINTER: u32 = 2u32;
pub const FORM_USER: u32 = 0u32;
#[repr(C)]
pub struct GLYPHRUN {
pub wcLow: u16,
pub wGlyphCount: u16,
}
impl ::core::marker::Copy for GLYPHRUN {}
impl ::core::clone::Clone for GLYPHRUN {
fn clone(&self) -> Self {
*self
}
}
pub const GPD_OEMCUSTOMDATA: u32 = 1u32;
pub const GUID_DEVINTERFACE_IPPUSB_PRINT: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
data1: 4076077953,
data2: 62573,
data3: 20049,
data4: [188, 231, 98, 222, 108, 242, 208, 152],
};
pub const GUID_DEVINTERFACE_USBPRINT: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 685215661, data2: 23058, data3: 4561, data4: [174, 91, 0, 0, 248, 3, 168, 194] };
pub type IAsyncGetSendNotificationCookie = *mut ::core::ffi::c_void;
pub type IAsyncGetSrvReferralCookie = *mut ::core::ffi::c_void;
pub type IBidiAsyncNotifyChannel = *mut ::core::ffi::c_void;
#[repr(C)]
pub struct IBidiRequest {
pub lpVtbl: *mut IBidiRequestVtbl,
}
impl ::core::marker::Copy for IBidiRequest {}
impl ::core::clone::Clone for IBidiRequest {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IBidiRequestContainer {
pub lpVtbl: *mut IBidiRequestContainerVtbl,
}
impl ::core::marker::Copy for IBidiRequestContainer {}
impl ::core::clone::Clone for IBidiRequestContainer {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IBidiRequestContainerVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub AddRequest: isize,
pub GetEnumObject: isize,
pub GetRequestCount: isize,
}
impl ::core::marker::Copy for IBidiRequestContainerVtbl {}
impl ::core::clone::Clone for IBidiRequestContainerVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IBidiRequestVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub SetSchema: isize,
pub SetInputData: isize,
pub GetResult: isize,
pub GetOutputData: isize,
pub GetEnumCount: isize,
}
impl ::core::marker::Copy for IBidiRequestVtbl {}
impl ::core::clone::Clone for IBidiRequestVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IBidiSpl {
pub lpVtbl: *mut IBidiSplVtbl,
}
impl ::core::marker::Copy for IBidiSpl {}
impl ::core::clone::Clone for IBidiSpl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IBidiSpl2 {
pub lpVtbl: *mut IBidiSpl2Vtbl,
}
impl ::core::marker::Copy for IBidiSpl2 {}
impl ::core::clone::Clone for IBidiSpl2 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IBidiSpl2Vtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub BindDevice: isize,
pub UnbindDevice: isize,
pub SendRecvXMLString: isize,
pub SendRecvXMLStream: isize,
}
impl ::core::marker::Copy for IBidiSpl2Vtbl {}
impl ::core::clone::Clone for IBidiSpl2Vtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IBidiSplVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub BindDevice: isize,
pub UnbindDevice: isize,
pub SendRecv: isize,
pub MultiSendRecv: isize,
}
impl ::core::marker::Copy for IBidiSplVtbl {}
impl ::core::clone::Clone for IBidiSplVtbl {
fn clone(&self) -> Self {
*self
}
}
pub const IDI_CPSUI_ADVANCE: u32 = 64058u32;
pub const IDI_CPSUI_AUTOSEL: u32 = 64025u32;
pub const IDI_CPSUI_COLLATE: u32 = 64030u32;
pub const IDI_CPSUI_COLOR: u32 = 64040u32;
pub const IDI_CPSUI_COPY: u32 = 64046u32;
pub const IDI_CPSUI_DEVICE: u32 = 64060u32;
pub const IDI_CPSUI_DEVICE2: u32 = 64061u32;
pub const IDI_CPSUI_DEVICE_FEATURE: u32 = 64080u32;
pub const IDI_CPSUI_DITHER_COARSE: u32 = 64042u32;
pub const IDI_CPSUI_DITHER_FINE: u32 = 64043u32;
pub const IDI_CPSUI_DITHER_LINEART: u32 = 64044u32;
pub const IDI_CPSUI_DITHER_NONE: u32 = 64041u32;
pub const IDI_CPSUI_DOCUMENT: u32 = 64059u32;
pub const IDI_CPSUI_DUPLEX_HORZ: u32 = 64032u32;
pub const IDI_CPSUI_DUPLEX_HORZ_L: u32 = 64085u32;
pub const IDI_CPSUI_DUPLEX_NONE: u32 = 64031u32;
pub const IDI_CPSUI_DUPLEX_NONE_L: u32 = 64084u32;
pub const IDI_CPSUI_DUPLEX_VERT: u32 = 64033u32;
pub const IDI_CPSUI_DUPLEX_VERT_L: u32 = 64086u32;
pub const IDI_CPSUI_EMPTY: u32 = 64000u32;
pub const IDI_CPSUI_ENVELOPE: u32 = 64010u32;
pub const IDI_CPSUI_ENVELOPE_FEED: u32 = 64097u32;
pub const IDI_CPSUI_ERROR: u32 = 64050u32;
pub const IDI_CPSUI_FALSE: u32 = 64005u32;
pub const IDI_CPSUI_FAX: u32 = 64095u32;
pub const IDI_CPSUI_FONTCART: u32 = 64013u32;
pub const IDI_CPSUI_FONTCARTHDR: u32 = 64012u32;
pub const IDI_CPSUI_FONTCART_SLOT: u32 = 64098u32;
pub const IDI_CPSUI_FONTSUB: u32 = 64081u32;
pub const IDI_CPSUI_FORMTRAYASSIGN: u32 = 64076u32;
pub const IDI_CPSUI_GENERIC_ITEM: u32 = 64073u32;
pub const IDI_CPSUI_GENERIC_OPTION: u32 = 64072u32;
pub const IDI_CPSUI_GRAPHIC: u32 = 64057u32;
pub const IDI_CPSUI_HALFTONE_SETUP: u32 = 64048u32;
pub const IDI_CPSUI_HTCLRADJ: u32 = 64047u32;
pub const IDI_CPSUI_HT_DEVICE: u32 = 64017u32;
pub const IDI_CPSUI_HT_HOST: u32 = 64016u32;
pub const IDI_CPSUI_ICM_INTENT: u32 = 64053u32;
pub const IDI_CPSUI_ICM_METHOD: u32 = 64052u32;
pub const IDI_CPSUI_ICM_OPTION: u32 = 64051u32;
pub const IDI_CPSUI_ICONID_FIRST: u32 = 64000u32;
pub const IDI_CPSUI_ICONID_LAST: u32 = 64111u32;
pub const IDI_CPSUI_INSTALLABLE_OPTION: u32 = 64078u32;
pub const IDI_CPSUI_LANDSCAPE: u32 = 64023u32;
pub const IDI_CPSUI_LAYOUT_BMP_ARROWL: u32 = 64100u32;
pub const IDI_CPSUI_LAYOUT_BMP_ARROWLR: u32 = 64104u32;
pub const IDI_CPSUI_LAYOUT_BMP_ARROWS: u32 = 64101u32;
pub const IDI_CPSUI_LAYOUT_BMP_BOOKLETL: u32 = 64102u32;
pub const IDI_CPSUI_LAYOUT_BMP_BOOKLETL_NB: u32 = 64106u32;
pub const IDI_CPSUI_LAYOUT_BMP_BOOKLETP: u32 = 64103u32;
pub const IDI_CPSUI_LAYOUT_BMP_BOOKLETP_NB: u32 = 64107u32;
pub const IDI_CPSUI_LAYOUT_BMP_PORTRAIT: u32 = 64099u32;
pub const IDI_CPSUI_LAYOUT_BMP_ROT_PORT: u32 = 64105u32;
pub const IDI_CPSUI_LF_PEN_PLOTTER: u32 = 64087u32;
pub const IDI_CPSUI_LF_RASTER_PLOTTER: u32 = 64089u32;
pub const IDI_CPSUI_MANUAL_FEED: u32 = 64094u32;
pub const IDI_CPSUI_MEM: u32 = 64011u32;
pub const IDI_CPSUI_MONO: u32 = 64039u32;
pub const IDI_CPSUI_NO: u32 = 64003u32;
pub const IDI_CPSUI_NOTINSTALLED: u32 = 64069u32;
pub const IDI_CPSUI_NUP_BORDER: u32 = 64111u32;
pub const IDI_CPSUI_OFF: u32 = 64007u32;
pub const IDI_CPSUI_ON: u32 = 64008u32;
pub const IDI_CPSUI_OPTION: u32 = 64066u32;
pub const IDI_CPSUI_OPTION2: u32 = 64067u32;
pub const IDI_CPSUI_OUTBIN: u32 = 64055u32;
pub const IDI_CPSUI_OUTPUT: u32 = 64056u32;
pub const IDI_CPSUI_PAGE_PROTECT: u32 = 64096u32;
pub const IDI_CPSUI_PAPER_OUTPUT: u32 = 64009u32;
pub const IDI_CPSUI_PAPER_TRAY: u32 = 64026u32;
pub const IDI_CPSUI_PAPER_TRAY2: u32 = 64027u32;
pub const IDI_CPSUI_PAPER_TRAY3: u32 = 64028u32;
pub const IDI_CPSUI_PEN_CARROUSEL: u32 = 64092u32;
pub const IDI_CPSUI_PLOTTER_PEN: u32 = 64093u32;
pub const IDI_CPSUI_PORTRAIT: u32 = 64022u32;
pub const IDI_CPSUI_POSTSCRIPT: u32 = 64082u32;
pub const IDI_CPSUI_PRINTER: u32 = 64062u32;
pub const IDI_CPSUI_PRINTER2: u32 = 64063u32;
pub const IDI_CPSUI_PRINTER3: u32 = 64064u32;
pub const IDI_CPSUI_PRINTER4: u32 = 64065u32;
pub const IDI_CPSUI_PRINTER_FEATURE: u32 = 64079u32;
pub const IDI_CPSUI_PRINTER_FOLDER: u32 = 64077u32;
pub const IDI_CPSUI_QUESTION: u32 = 64075u32;
pub const IDI_CPSUI_RES_DRAFT: u32 = 64034u32;
pub const IDI_CPSUI_RES_HIGH: u32 = 64037u32;
pub const IDI_CPSUI_RES_LOW: u32 = 64035u32;
pub const IDI_CPSUI_RES_MEDIUM: u32 = 64036u32;
pub const IDI_CPSUI_RES_PRESENTATION: u32 = 64038u32;
pub const IDI_CPSUI_ROLL_PAPER: u32 = 64091u32;
pub const IDI_CPSUI_ROT_LAND: u32 = 64024u32;
pub const IDI_CPSUI_ROT_PORT: u32 = 64110u32;
pub const IDI_CPSUI_RUN_DIALOG: u32 = 64074u32;
pub const IDI_CPSUI_SCALING: u32 = 64045u32;
pub const IDI_CPSUI_SEL_NONE: u32 = 64001u32;
pub const IDI_CPSUI_SF_PEN_PLOTTER: u32 = 64088u32;
pub const IDI_CPSUI_SF_RASTER_PLOTTER: u32 = 64090u32;
pub const IDI_CPSUI_STAPLER_OFF: u32 = 64015u32;
pub const IDI_CPSUI_STAPLER_ON: u32 = 64014u32;
pub const IDI_CPSUI_STD_FORM: u32 = 64054u32;
pub const IDI_CPSUI_STOP: u32 = 64068u32;
pub const IDI_CPSUI_STOP_WARNING_OVERLAY: u32 = 64071u32;
pub const IDI_CPSUI_TELEPHONE: u32 = 64083u32;
pub const IDI_CPSUI_TRANSPARENT: u32 = 64029u32;
pub const IDI_CPSUI_TRUE: u32 = 64006u32;
pub const IDI_CPSUI_TT_DOWNLOADSOFT: u32 = 64019u32;
pub const IDI_CPSUI_TT_DOWNLOADVECT: u32 = 64020u32;
pub const IDI_CPSUI_TT_PRINTASGRAPHIC: u32 = 64018u32;
pub const IDI_CPSUI_TT_SUBDEV: u32 = 64021u32;
pub const IDI_CPSUI_WARNING: u32 = 64002u32;
pub const IDI_CPSUI_WARNING_OVERLAY: u32 = 64070u32;
pub const IDI_CPSUI_WATERMARK: u32 = 64049u32;
pub const IDI_CPSUI_YES: u32 = 64004u32;
pub const IDS_CPSUI_ABOUT: u32 = 64848u32;
pub const IDS_CPSUI_ADVANCED: u32 = 64722u32;
pub const IDS_CPSUI_ADVANCEDOCUMENT: u32 = 64716u32;
pub const IDS_CPSUI_ALL: u32 = 64841u32;
pub const IDS_CPSUI_AUTOSELECT: u32 = 64718u32;
pub const IDS_CPSUI_BACKTOFRONT: u32 = 64857u32;
pub const IDS_CPSUI_BOND: u32 = 64786u32;
pub const IDS_CPSUI_BOOKLET: u32 = 64873u32;
pub const IDS_CPSUI_BOOKLET_EDGE: u32 = 64888u32;
pub const IDS_CPSUI_BOOKLET_EDGE_LEFT: u32 = 64889u32;
pub const IDS_CPSUI_BOOKLET_EDGE_RIGHT: u32 = 64890u32;
pub const IDS_CPSUI_CASSETTE_TRAY: u32 = 64810u32;
pub const IDS_CPSUI_CHANGE: u32 = 64702u32;
pub const IDS_CPSUI_CHANGED: u32 = 64846u32;
pub const IDS_CPSUI_CHANGES: u32 = 64845u32;
pub const IDS_CPSUI_COARSE: u32 = 64787u32;
pub const IDS_CPSUI_COLLATE: u32 = 64756u32;
pub const IDS_CPSUI_COLLATED: u32 = 64757u32;
pub const IDS_CPSUI_COLON_SEP: u32 = 64707u32;
pub const IDS_CPSUI_COLOR: u32 = 64764u32;
pub const IDS_CPSUI_COLOR_APPERANCE: u32 = 64744u32;
pub const IDS_CPSUI_COPIES: u32 = 64831u32;
pub const IDS_CPSUI_COPY: u32 = 64830u32;
pub const IDS_CPSUI_DEFAULT: u32 = 64732u32;
pub const IDS_CPSUI_DEFAULTDOCUMENT: u32 = 64714u32;
pub const IDS_CPSUI_DEFAULT_TRAY: u32 = 64811u32;
pub const IDS_CPSUI_DEVICE: u32 = 64842u32;
pub const IDS_CPSUI_DEVICEOPTIONS: u32 = 64725u32;
pub const IDS_CPSUI_DEVICE_SETTINGS: u32 = 64852u32;
pub const IDS_CPSUI_DITHERING: u32 = 64752u32;
pub const IDS_CPSUI_DOCUMENT: u32 = 64715u32;
pub const IDS_CPSUI_DOWN_THEN_LEFT: u32 = 64882u32;
pub const IDS_CPSUI_DOWN_THEN_RIGHT: u32 = 64880u32;
pub const IDS_CPSUI_DRAFT: u32 = 64759u32;
pub const IDS_CPSUI_DUPLEX: u32 = 64745u32;
pub const IDS_CPSUI_ENVELOPE_TRAY: u32 = 64804u32;
pub const IDS_CPSUI_ENVMANUAL_TRAY: u32 = 64805u32;
pub const IDS_CPSUI_ERRDIFFUSE: u32 = 64790u32;
pub const IDS_CPSUI_ERROR: u32 = 64733u32;
pub const IDS_CPSUI_EXIST: u32 = 64736u32;
pub const IDS_CPSUI_FALSE: u32 = 64726u32;
pub const IDS_CPSUI_FAST: u32 = 64838u32;
pub const IDS_CPSUI_FAX: u32 = 64835u32;
pub const IDS_CPSUI_FINE: u32 = 64788u32;
pub const IDS_CPSUI_FORMNAME: u32 = 64747u32;
pub const IDS_CPSUI_FORMSOURCE: u32 = 64812u32;
pub const IDS_CPSUI_FORMTRAYASSIGN: u32 = 64798u32;
pub const IDS_CPSUI_FRONTTOBACK: u32 = 64856u32;
pub const IDS_CPSUI_GLOSSY: u32 = 64783u32;
pub const IDS_CPSUI_GRAPHIC: u32 = 64720u32;
pub const IDS_CPSUI_GRAYSCALE: u32 = 64765u32;
pub const IDS_CPSUI_HALFTONE: u32 = 64791u32;
pub const IDS_CPSUI_HALFTONE_SETUP: u32 = 64817u32;
pub const IDS_CPSUI_HIGH: u32 = 64762u32;
pub const IDS_CPSUI_HORIZONTAL: u32 = 64768u32;
pub const IDS_CPSUI_HTCLRADJ: u32 = 64792u32;
pub const IDS_CPSUI_ICM: u32 = 64748u32;
pub const IDS_CPSUI_ICMINTENT: u32 = 64750u32;
pub const IDS_CPSUI_ICMMETHOD: u32 = 64749u32;
pub const IDS_CPSUI_ICM_BLACKWHITE: u32 = 64776u32;
pub const IDS_CPSUI_ICM_COLORMETRIC: u32 = 64781u32;
pub const IDS_CPSUI_ICM_CONTRAST: u32 = 64780u32;
pub const IDS_CPSUI_ICM_NO: u32 = 64777u32;
pub const IDS_CPSUI_ICM_SATURATION: u32 = 64779u32;
pub const IDS_CPSUI_ICM_YES: u32 = 64778u32;
pub const IDS_CPSUI_INSTFONTCART: u32 = 64818u32;
pub const IDS_CPSUI_LANDSCAPE: u32 = 64754u32;
pub const IDS_CPSUI_LARGECAP_TRAY: u32 = 64809u32;
pub const IDS_CPSUI_LARGEFMT_TRAY: u32 = 64808u32;
pub const IDS_CPSUI_LBCB_NOSEL: u32 = 64712u32;
pub const IDS_CPSUI_LEFT_ANGLE: u32 = 64708u32;
pub const IDS_CPSUI_LEFT_SLOT: u32 = 64823u32;
pub const IDS_CPSUI_LEFT_THEN_DOWN: u32 = 64881u32;
pub const IDS_CPSUI_LINEART: u32 = 64789u32;
pub const IDS_CPSUI_LONG_SIDE: u32 = 64770u32;
pub const IDS_CPSUI_LOW: u32 = 64760u32;
pub const IDS_CPSUI_LOWER_TRAY: u32 = 64801u32;
pub const IDS_CPSUI_MAILBOX: u32 = 64829u32;
pub const IDS_CPSUI_MAKE: u32 = 64833u32;
pub const IDS_CPSUI_MANUALFEED: u32 = 64813u32;
pub const IDS_CPSUI_MANUAL_DUPLEX: u32 = 64883u32;
pub const IDS_CPSUI_MANUAL_DUPLEX_OFF: u32 = 64885u32;
pub const IDS_CPSUI_MANUAL_DUPLEX_ON: u32 = 64884u32;
pub const IDS_CPSUI_MANUAL_TRAY: u32 = 64803u32;
pub const IDS_CPSUI_MEDIA: u32 = 64751u32;
pub const IDS_CPSUI_MEDIUM: u32 = 64761u32;
pub const IDS_CPSUI_MIDDLE_TRAY: u32 = 64802u32;
pub const IDS_CPSUI_MONOCHROME: u32 = 64766u32;
pub const IDS_CPSUI_MORE: u32 = 64701u32;
pub const IDS_CPSUI_NO: u32 = 64728u32;
pub const IDS_CPSUI_NONE: u32 = 64734u32;
pub const IDS_CPSUI_NOT: u32 = 64735u32;
pub const IDS_CPSUI_NOTINSTALLED: u32 = 64737u32;
pub const IDS_CPSUI_NO_NAME: u32 = 64850u32;
pub const IDS_CPSUI_NUM_OF_COPIES: u32 = 64740u32;
pub const IDS_CPSUI_NUP: u32 = 64864u32;
pub const IDS_CPSUI_NUP_BORDER: u32 = 64891u32;
pub const IDS_CPSUI_NUP_BORDERED: u32 = 64892u32;
pub const IDS_CPSUI_NUP_DIRECTION: u32 = 64878u32;
pub const IDS_CPSUI_NUP_FOURUP: u32 = 64867u32;
pub const IDS_CPSUI_NUP_NINEUP: u32 = 64869u32;
pub const IDS_CPSUI_NUP_NORMAL: u32 = 64865u32;
pub const IDS_CPSUI_NUP_SIXTEENUP: u32 = 64870u32;
pub const IDS_CPSUI_NUP_SIXUP: u32 = 64868u32;
pub const IDS_CPSUI_NUP_TWOUP: u32 = 64866u32;
pub const IDS_CPSUI_OF: u32 = 64704u32;
pub const IDS_CPSUI_OFF: u32 = 64730u32;
pub const IDS_CPSUI_ON: u32 = 64731u32;
pub const IDS_CPSUI_ONLYONE: u32 = 64800u32;
pub const IDS_CPSUI_OPTION: u32 = 64703u32;
pub const IDS_CPSUI_OPTIONS: u32 = 64721u32;
pub const IDS_CPSUI_ORIENTATION: u32 = 64738u32;
pub const IDS_CPSUI_OUTBINASSIGN: u32 = 64796u32;
pub const IDS_CPSUI_OUTPUTBIN: u32 = 64863u32;
pub const IDS_CPSUI_PAGEORDER: u32 = 64855u32;
pub const IDS_CPSUI_PAGEPROTECT: u32 = 64816u32;
pub const IDS_CPSUI_PAPER_OUTPUT: u32 = 64719u32;
pub const IDS_CPSUI_PERCENT: u32 = 64711u32;
pub const IDS_CPSUI_PLOT: u32 = 64836u32;
pub const IDS_CPSUI_PORTRAIT: u32 = 64753u32;
pub const IDS_CPSUI_POSTER: u32 = 64874u32;
pub const IDS_CPSUI_POSTER_2x2: u32 = 64875u32;
pub const IDS_CPSUI_POSTER_3x3: u32 = 64876u32;
pub const IDS_CPSUI_POSTER_4x4: u32 = 64877u32;
pub const IDS_CPSUI_PRESENTATION: u32 = 64763u32;
pub const IDS_CPSUI_PRINT: u32 = 64834u32;
pub const IDS_CPSUI_PRINTER: u32 = 64717u32;
pub const IDS_CPSUI_PRINTERMEM_KB: u32 = 64814u32;
pub const IDS_CPSUI_PRINTERMEM_MB: u32 = 64815u32;
pub const IDS_CPSUI_PRINTFLDSETTING: u32 = 64758u32;
pub const IDS_CPSUI_PRINTQUALITY: u32 = 64742u32;
pub const IDS_CPSUI_PROPERTIES: u32 = 64713u32;
pub const IDS_CPSUI_QUALITY_BEST: u32 = 64861u32;
pub const IDS_CPSUI_QUALITY_BETTER: u32 = 64860u32;
pub const IDS_CPSUI_QUALITY_CUSTOM: u32 = 64862u32;
pub const IDS_CPSUI_QUALITY_DRAFT: u32 = 64859u32;
pub const IDS_CPSUI_QUALITY_SETTINGS: u32 = 64858u32;
pub const IDS_CPSUI_RANGE_FROM: u32 = 64705u32;
pub const IDS_CPSUI_REGULAR: u32 = 64785u32;
pub const IDS_CPSUI_RESET: u32 = 64840u32;
pub const IDS_CPSUI_RESOLUTION: u32 = 64743u32;
pub const IDS_CPSUI_REVERT: u32 = 64844u32;
pub const IDS_CPSUI_RIGHT_ANGLE: u32 = 64709u32;
pub const IDS_CPSUI_RIGHT_SLOT: u32 = 64824u32;
pub const IDS_CPSUI_RIGHT_THEN_DOWN: u32 = 64879u32;
pub const IDS_CPSUI_ROTATED: u32 = 64839u32;
pub const IDS_CPSUI_ROT_LAND: u32 = 64755u32;
pub const IDS_CPSUI_ROT_PORT: u32 = 64886u32;
pub const IDS_CPSUI_SCALING: u32 = 64739u32;
pub const IDS_CPSUI_SETTING: u32 = 64851u32;
pub const IDS_CPSUI_SETTINGS: u32 = 64843u32;
pub const IDS_CPSUI_SETUP: u32 = 64700u32;
pub const IDS_CPSUI_SHORT_SIDE: u32 = 64771u32;
pub const IDS_CPSUI_SIDE1: u32 = 64871u32;
pub const IDS_CPSUI_SIDE2: u32 = 64872u32;
pub const IDS_CPSUI_SIMPLEX: u32 = 64767u32;
pub const IDS_CPSUI_SLASH_SEP: u32 = 64710u32;
pub const IDS_CPSUI_SLOT1: u32 = 64819u32;
pub const IDS_CPSUI_SLOT2: u32 = 64820u32;
pub const IDS_CPSUI_SLOT3: u32 = 64821u32;
pub const IDS_CPSUI_SLOT4: u32 = 64822u32;
pub const IDS_CPSUI_SLOW: u32 = 64837u32;
pub const IDS_CPSUI_SMALLFMT_TRAY: u32 = 64807u32;
pub const IDS_CPSUI_SOURCE: u32 = 64741u32;
pub const IDS_CPSUI_STACKER: u32 = 64828u32;
pub const IDS_CPSUI_STANDARD: u32 = 64782u32;
pub const IDS_CPSUI_STAPLE: u32 = 64887u32;
pub const IDS_CPSUI_STAPLER: u32 = 64825u32;
pub const IDS_CPSUI_STAPLER_OFF: u32 = 64827u32;
pub const IDS_CPSUI_STAPLER_ON: u32 = 64826u32;
pub const IDS_CPSUI_STDDOCPROPTAB: u32 = 64723u32;
pub const IDS_CPSUI_STDDOCPROPTAB1: u32 = 64853u32;
pub const IDS_CPSUI_STDDOCPROPTAB2: u32 = 64854u32;
pub const IDS_CPSUI_STDDOCPROPTVTAB: u32 = 64724u32;
pub const IDS_CPSUI_STRID_FIRST: u32 = 64700u32;
pub const IDS_CPSUI_STRID_LAST: u32 = 64892u32;
pub const IDS_CPSUI_TO: u32 = 64706u32;
pub const IDS_CPSUI_TOTAL: u32 = 64832u32;
pub const IDS_CPSUI_TRACTOR_TRAY: u32 = 64806u32;
pub const IDS_CPSUI_TRANSPARENCY: u32 = 64784u32;
pub const IDS_CPSUI_TRUE: u32 = 64727u32;
pub const IDS_CPSUI_TTOPTION: u32 = 64746u32;
pub const IDS_CPSUI_TT_DOWNLOADSOFT: u32 = 64773u32;
pub const IDS_CPSUI_TT_DOWNLOADVECT: u32 = 64774u32;
pub const IDS_CPSUI_TT_PRINTASGRAPHIC: u32 = 64772u32;
pub const IDS_CPSUI_TT_SUBDEV: u32 = 64775u32;
pub const IDS_CPSUI_UPPER_TRAY: u32 = 64799u32;
pub const IDS_CPSUI_USE_DEVICE_HT: u32 = 64794u32;
pub const IDS_CPSUI_USE_HOST_HT: u32 = 64793u32;
pub const IDS_CPSUI_USE_PRINTER_HT: u32 = 64795u32;
pub const IDS_CPSUI_VERSION: u32 = 64849u32;
pub const IDS_CPSUI_VERTICAL: u32 = 64769u32;
pub const IDS_CPSUI_WARNING: u32 = 64847u32;
pub const IDS_CPSUI_WATERMARK: u32 = 64797u32;
pub const IDS_CPSUI_YES: u32 = 64729u32;
#[repr(C)]
pub struct IFixedDocument {
pub lpVtbl: *mut IFixedDocumentVtbl,
}
impl ::core::marker::Copy for IFixedDocument {}
impl ::core::clone::Clone for IFixedDocument {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IFixedDocumentSequence {
pub lpVtbl: *mut IFixedDocumentSequenceVtbl,
}
impl ::core::marker::Copy for IFixedDocumentSequence {}
impl ::core::clone::Clone for IFixedDocumentSequence {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IFixedDocumentSequenceVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetUri: isize,
pub GetPrintTicket: isize,
pub SetPrintTicket: isize,
}
impl ::core::marker::Copy for IFixedDocumentSequenceVtbl {}
impl ::core::clone::Clone for IFixedDocumentSequenceVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IFixedDocumentVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetUri: isize,
pub GetPrintTicket: isize,
pub SetPrintTicket: isize,
}
impl ::core::marker::Copy for IFixedDocumentVtbl {}
impl ::core::clone::Clone for IFixedDocumentVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IFixedPage {
pub lpVtbl: *mut IFixedPageVtbl,
}
impl ::core::marker::Copy for IFixedPage {}
impl ::core::clone::Clone for IFixedPage {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IFixedPageVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetUri: isize,
pub GetStream: isize,
pub GetPartCompression: isize,
pub SetPartCompression: isize,
pub GetPrintTicket: isize,
pub GetPagePart: isize,
pub GetWriteStream: isize,
pub SetPrintTicket: isize,
pub SetPagePart: isize,
pub DeleteResource: isize,
pub GetXpsPartIterator: isize,
}
impl ::core::marker::Copy for IFixedPageVtbl {}
impl ::core::clone::Clone for IFixedPageVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IImgCreateErrorInfo {
pub lpVtbl: *mut IImgCreateErrorInfoVtbl,
}
impl ::core::marker::Copy for IImgCreateErrorInfo {}
impl ::core::clone::Clone for IImgCreateErrorInfo {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IImgCreateErrorInfoVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub SetGUID: isize,
pub SetSource: isize,
pub SetDescription: isize,
pub SetHelpFile: isize,
pub SetHelpContext: isize,
pub AttachToErrorInfo: isize,
}
impl ::core::marker::Copy for IImgCreateErrorInfoVtbl {}
impl ::core::clone::Clone for IImgCreateErrorInfoVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IImgErrorInfo {
pub lpVtbl: *mut IImgErrorInfoVtbl,
}
impl ::core::marker::Copy for IImgErrorInfo {}
impl ::core::clone::Clone for IImgErrorInfo {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IImgErrorInfoVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetGUID: isize,
pub GetSource: isize,
pub GetDescription: isize,
pub GetHelpFile: isize,
pub GetHelpContext: isize,
pub GetDeveloperDescription: isize,
pub GetUserErrorId: isize,
pub GetUserParameterCount: isize,
pub GetUserParameter: isize,
pub GetUserFallback: isize,
pub GetExceptionId: isize,
pub DetachErrorInfo: isize,
}
impl ::core::marker::Copy for IImgErrorInfoVtbl {}
impl ::core::clone::Clone for IImgErrorInfoVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IInterFilterCommunicator {
pub lpVtbl: *mut IInterFilterCommunicatorVtbl,
}
impl ::core::marker::Copy for IInterFilterCommunicator {}
impl ::core::clone::Clone for IInterFilterCommunicator {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IInterFilterCommunicatorVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub RequestReader: isize,
pub RequestWriter: isize,
}
impl ::core::marker::Copy for IInterFilterCommunicatorVtbl {}
impl ::core::clone::Clone for IInterFilterCommunicatorVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct INSERTPSUIPAGE_INFO {
pub cbSize: u16,
pub Type: u8,
pub Mode: u8,
pub dwData1: usize,
pub dwData2: usize,
pub dwData3: usize,
}
impl ::core::marker::Copy for INSERTPSUIPAGE_INFO {}
impl ::core::clone::Clone for INSERTPSUIPAGE_INFO {
fn clone(&self) -> Self {
*self
}
}
pub const INSPSUIPAGE_MODE_AFTER: u32 = 1u32;
pub const INSPSUIPAGE_MODE_BEFORE: u32 = 0u32;
pub const INSPSUIPAGE_MODE_FIRST_CHILD: u32 = 2u32;
pub const INSPSUIPAGE_MODE_INDEX: u32 = 4u32;
pub const INSPSUIPAGE_MODE_LAST_CHILD: u32 = 3u32;
#[repr(C)]
pub struct INVOC {
pub dwCount: u32,
pub loOffset: u32,
}
impl ::core::marker::Copy for INVOC {}
impl ::core::clone::Clone for INVOC {
fn clone(&self) -> Self {
*self
}
}
pub const IOCTL_USBPRINT_ADD_CHILD_DEVICE: u32 = 2228316u32;
pub const IOCTL_USBPRINT_ADD_MSIPP_COMPAT_ID: u32 = 2228308u32;
pub const IOCTL_USBPRINT_CYCLE_PORT: u32 = 2228320u32;
pub const IOCTL_USBPRINT_GET_1284_ID: u32 = 2228276u32;
pub const IOCTL_USBPRINT_GET_INTERFACE_TYPE: u32 = 2228300u32;
pub const IOCTL_USBPRINT_GET_LPT_STATUS: u32 = 2228272u32;
pub const IOCTL_USBPRINT_GET_PROTOCOL: u32 = 2228292u32;
pub const IOCTL_USBPRINT_SET_DEVICE_ID: u32 = 2228312u32;
pub const IOCTL_USBPRINT_SET_PORT_NUMBER: u32 = 2228304u32;
pub const IOCTL_USBPRINT_SET_PROTOCOL: u32 = 2228296u32;
pub const IOCTL_USBPRINT_SOFT_RESET: u32 = 2228288u32;
pub const IOCTL_USBPRINT_VENDOR_GET_COMMAND: u32 = 2228284u32;
pub const IOCTL_USBPRINT_VENDOR_SET_COMMAND: u32 = 2228280u32;
pub const IPDFP_COPY_ALL_FILES: u32 = 1u32;
#[repr(C)]
pub struct IPartBase {
pub lpVtbl: *mut IPartBaseVtbl,
}
impl ::core::marker::Copy for IPartBase {}
impl ::core::clone::Clone for IPartBase {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartBaseVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetUri: isize,
pub GetStream: isize,
pub GetPartCompression: isize,
pub SetPartCompression: isize,
}
impl ::core::marker::Copy for IPartBaseVtbl {}
impl ::core::clone::Clone for IPartBaseVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartColorProfile {
pub lpVtbl: *mut IPartColorProfileVtbl,
}
impl ::core::marker::Copy for IPartColorProfile {}
impl ::core::clone::Clone for IPartColorProfile {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartColorProfileVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetUri: isize,
pub GetStream: isize,
pub GetPartCompression: isize,
pub SetPartCompression: isize,
}
impl ::core::marker::Copy for IPartColorProfileVtbl {}
impl ::core::clone::Clone for IPartColorProfileVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartDiscardControl {
pub lpVtbl: *mut IPartDiscardControlVtbl,
}
impl ::core::marker::Copy for IPartDiscardControl {}
impl ::core::clone::Clone for IPartDiscardControl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartDiscardControlVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetDiscardProperties: isize,
}
impl ::core::marker::Copy for IPartDiscardControlVtbl {}
impl ::core::clone::Clone for IPartDiscardControlVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartFont {
pub lpVtbl: *mut IPartFontVtbl,
}
impl ::core::marker::Copy for IPartFont {}
impl ::core::clone::Clone for IPartFont {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartFont2 {
pub lpVtbl: *mut IPartFont2Vtbl,
}
impl ::core::marker::Copy for IPartFont2 {}
impl ::core::clone::Clone for IPartFont2 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartFont2Vtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetUri: isize,
pub GetStream: isize,
pub GetPartCompression: isize,
pub SetPartCompression: isize,
pub GetFontProperties: isize,
pub SetFontContent: isize,
pub SetFontOptions: isize,
pub GetFontRestriction: isize,
}
impl ::core::marker::Copy for IPartFont2Vtbl {}
impl ::core::clone::Clone for IPartFont2Vtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartFontVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetUri: isize,
pub GetStream: isize,
pub GetPartCompression: isize,
pub SetPartCompression: isize,
pub GetFontProperties: isize,
pub SetFontContent: isize,
pub SetFontOptions: isize,
}
impl ::core::marker::Copy for IPartFontVtbl {}
impl ::core::clone::Clone for IPartFontVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartImage {
pub lpVtbl: *mut IPartImageVtbl,
}
impl ::core::marker::Copy for IPartImage {}
impl ::core::clone::Clone for IPartImage {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartImageVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetUri: isize,
pub GetStream: isize,
pub GetPartCompression: isize,
pub SetPartCompression: isize,
pub GetImageProperties: isize,
pub SetImageContent: isize,
}
impl ::core::marker::Copy for IPartImageVtbl {}
impl ::core::clone::Clone for IPartImageVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartPrintTicket {
pub lpVtbl: *mut IPartPrintTicketVtbl,
}
impl ::core::marker::Copy for IPartPrintTicket {}
impl ::core::clone::Clone for IPartPrintTicket {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartPrintTicketVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetUri: isize,
pub GetStream: isize,
pub GetPartCompression: isize,
pub SetPartCompression: isize,
}
impl ::core::marker::Copy for IPartPrintTicketVtbl {}
impl ::core::clone::Clone for IPartPrintTicketVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartResourceDictionary {
pub lpVtbl: *mut IPartResourceDictionaryVtbl,
}
impl ::core::marker::Copy for IPartResourceDictionary {}
impl ::core::clone::Clone for IPartResourceDictionary {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartResourceDictionaryVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetUri: isize,
pub GetStream: isize,
pub GetPartCompression: isize,
pub SetPartCompression: isize,
}
impl ::core::marker::Copy for IPartResourceDictionaryVtbl {}
impl ::core::clone::Clone for IPartResourceDictionaryVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartThumbnail {
pub lpVtbl: *mut IPartThumbnailVtbl,
}
impl ::core::marker::Copy for IPartThumbnail {}
impl ::core::clone::Clone for IPartThumbnail {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPartThumbnailVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetUri: isize,
pub GetStream: isize,
pub GetPartCompression: isize,
pub SetPartCompression: isize,
pub GetThumbnailProperties: isize,
pub SetThumbnailContent: isize,
}
impl ::core::marker::Copy for IPartThumbnailVtbl {}
impl ::core::clone::Clone for IPartThumbnailVtbl {
fn clone(&self) -> Self {
*self
}
}
pub type IPrintAsyncCookie = *mut ::core::ffi::c_void;
pub type IPrintAsyncNewChannelCookie = *mut ::core::ffi::c_void;
pub type IPrintAsyncNotify = *mut ::core::ffi::c_void;
pub type IPrintAsyncNotifyCallback = *mut ::core::ffi::c_void;
pub type IPrintAsyncNotifyChannel = *mut ::core::ffi::c_void;
pub type IPrintAsyncNotifyDataObject = *mut ::core::ffi::c_void;
pub type IPrintAsyncNotifyRegistration = *mut ::core::ffi::c_void;
pub type IPrintAsyncNotifyServerReferral = *mut ::core::ffi::c_void;
pub type IPrintBidiAsyncNotifyRegistration = *mut ::core::ffi::c_void;
#[repr(C)]
pub struct IPrintClassObjectFactory {
pub lpVtbl: *mut IPrintClassObjectFactoryVtbl,
}
impl ::core::marker::Copy for IPrintClassObjectFactory {}
impl ::core::clone::Clone for IPrintClassObjectFactory {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintClassObjectFactoryVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetPrintClassObject: isize,
}
impl ::core::marker::Copy for IPrintClassObjectFactoryVtbl {}
impl ::core::clone::Clone for IPrintClassObjectFactoryVtbl {
fn clone(&self) -> Self {
*self
}
}
pub type IPrintCoreHelper = *mut ::core::ffi::c_void;
pub type IPrintCoreHelperPS = *mut ::core::ffi::c_void;
pub type IPrintCoreHelperUni = *mut ::core::ffi::c_void;
pub type IPrintCoreHelperUni2 = *mut ::core::ffi::c_void;
pub type IPrintCoreUI2 = *mut ::core::ffi::c_void;
pub type IPrintJob = *mut ::core::ffi::c_void;
pub type IPrintJobCollection = *mut ::core::ffi::c_void;
pub type IPrintOemCommon = *mut ::core::ffi::c_void;
pub type IPrintOemDriverUI = *mut ::core::ffi::c_void;
pub type IPrintOemUI = *mut ::core::ffi::c_void;
pub type IPrintOemUI2 = *mut ::core::ffi::c_void;
pub type IPrintOemUIMXDC = *mut ::core::ffi::c_void;
#[repr(C)]
pub struct IPrintPipelineFilter {
pub lpVtbl: *mut IPrintPipelineFilterVtbl,
}
impl ::core::marker::Copy for IPrintPipelineFilter {}
impl ::core::clone::Clone for IPrintPipelineFilter {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintPipelineFilterVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub InitializeFilter: isize,
pub ShutdownOperation: isize,
pub StartOperation: isize,
}
impl ::core::marker::Copy for IPrintPipelineFilterVtbl {}
impl ::core::clone::Clone for IPrintPipelineFilterVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintPipelineManagerControl {
pub lpVtbl: *mut IPrintPipelineManagerControlVtbl,
}
impl ::core::marker::Copy for IPrintPipelineManagerControl {}
impl ::core::clone::Clone for IPrintPipelineManagerControl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintPipelineManagerControlVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub RequestShutdown: isize,
pub FilterFinished: isize,
}
impl ::core::marker::Copy for IPrintPipelineManagerControlVtbl {}
impl ::core::clone::Clone for IPrintPipelineManagerControlVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintPipelineProgressReport {
pub lpVtbl: *mut IPrintPipelineProgressReportVtbl,
}
impl ::core::marker::Copy for IPrintPipelineProgressReport {}
impl ::core::clone::Clone for IPrintPipelineProgressReport {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintPipelineProgressReportVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub ReportProgress: isize,
}
impl ::core::marker::Copy for IPrintPipelineProgressReportVtbl {}
impl ::core::clone::Clone for IPrintPipelineProgressReportVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintPipelinePropertyBag {
pub lpVtbl: *mut IPrintPipelinePropertyBagVtbl,
}
impl ::core::marker::Copy for IPrintPipelinePropertyBag {}
impl ::core::clone::Clone for IPrintPipelinePropertyBag {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintPipelinePropertyBagVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub AddProperty: isize,
pub GetProperty: isize,
pub DeleteProperty: isize,
}
impl ::core::marker::Copy for IPrintPipelinePropertyBagVtbl {}
impl ::core::clone::Clone for IPrintPipelinePropertyBagVtbl {
fn clone(&self) -> Self {
*self
}
}
pub type IPrintPreviewDxgiPackageTarget = *mut ::core::ffi::c_void;
#[repr(C)]
pub struct IPrintReadStream {
pub lpVtbl: *mut IPrintReadStreamVtbl,
}
impl ::core::marker::Copy for IPrintReadStream {}
impl ::core::clone::Clone for IPrintReadStream {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintReadStreamFactory {
pub lpVtbl: *mut IPrintReadStreamFactoryVtbl,
}
impl ::core::marker::Copy for IPrintReadStreamFactory {}
impl ::core::clone::Clone for IPrintReadStreamFactory {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintReadStreamFactoryVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetStream: isize,
}
impl ::core::marker::Copy for IPrintReadStreamFactoryVtbl {}
impl ::core::clone::Clone for IPrintReadStreamFactoryVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintReadStreamVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub Seek: isize,
pub ReadBytes: isize,
}
impl ::core::marker::Copy for IPrintReadStreamVtbl {}
impl ::core::clone::Clone for IPrintReadStreamVtbl {
fn clone(&self) -> Self {
*self
}
}
pub type IPrintSchemaAsyncOperation = *mut ::core::ffi::c_void;
pub type IPrintSchemaAsyncOperationEvent = *mut ::core::ffi::c_void;
pub type IPrintSchemaCapabilities = *mut ::core::ffi::c_void;
pub type IPrintSchemaCapabilities2 = *mut ::core::ffi::c_void;
pub type IPrintSchemaDisplayableElement = *mut ::core::ffi::c_void;
pub type IPrintSchemaElement = *mut ::core::ffi::c_void;
pub type IPrintSchemaFeature = *mut ::core::ffi::c_void;
pub type IPrintSchemaNUpOption = *mut ::core::ffi::c_void;
pub type IPrintSchemaOption = *mut ::core::ffi::c_void;
pub type IPrintSchemaOptionCollection = *mut ::core::ffi::c_void;
pub type IPrintSchemaPageImageableSize = *mut ::core::ffi::c_void;
pub type IPrintSchemaPageMediaSizeOption = *mut ::core::ffi::c_void;
pub type IPrintSchemaParameterDefinition = *mut ::core::ffi::c_void;
pub type IPrintSchemaParameterInitializer = *mut ::core::ffi::c_void;
pub type IPrintSchemaTicket = *mut ::core::ffi::c_void;
pub type IPrintSchemaTicket2 = *mut ::core::ffi::c_void;
pub type IPrintTicketProvider = *mut ::core::ffi::c_void;
pub type IPrintTicketProvider2 = *mut ::core::ffi::c_void;
pub type IPrintUnidiAsyncNotifyRegistration = *mut ::core::ffi::c_void;
#[repr(C)]
pub struct IPrintWriteStream {
pub lpVtbl: *mut IPrintWriteStreamVtbl,
}
impl ::core::marker::Copy for IPrintWriteStream {}
impl ::core::clone::Clone for IPrintWriteStream {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintWriteStreamFlush {
pub lpVtbl: *mut IPrintWriteStreamFlushVtbl,
}
impl ::core::marker::Copy for IPrintWriteStreamFlush {}
impl ::core::clone::Clone for IPrintWriteStreamFlush {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintWriteStreamFlushVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub FlushData: isize,
}
impl ::core::marker::Copy for IPrintWriteStreamFlushVtbl {}
impl ::core::clone::Clone for IPrintWriteStreamFlushVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IPrintWriteStreamVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub WriteBytes: isize,
pub Close: isize,
}
impl ::core::marker::Copy for IPrintWriteStreamVtbl {}
impl ::core::clone::Clone for IPrintWriteStreamVtbl {
fn clone(&self) -> Self {
*self
}
}
pub type IPrinterBidiSetRequestCallback = *mut ::core::ffi::c_void;
pub type IPrinterExtensionAsyncOperation = *mut ::core::ffi::c_void;
pub type IPrinterExtensionContext = *mut ::core::ffi::c_void;
pub type IPrinterExtensionContextCollection = *mut ::core::ffi::c_void;
pub type IPrinterExtensionEvent = *mut ::core::ffi::c_void;
pub type IPrinterExtensionEventArgs = *mut ::core::ffi::c_void;
pub type IPrinterExtensionManager = *mut ::core::ffi::c_void;
pub type IPrinterExtensionRequest = *mut ::core::ffi::c_void;
pub type IPrinterPropertyBag = *mut ::core::ffi::c_void;
pub type IPrinterQueue = *mut ::core::ffi::c_void;
pub type IPrinterQueue2 = *mut ::core::ffi::c_void;
pub type IPrinterQueueEvent = *mut ::core::ffi::c_void;
pub type IPrinterQueueView = *mut ::core::ffi::c_void;
pub type IPrinterQueueViewEvent = *mut ::core::ffi::c_void;
pub type IPrinterScriptContext = *mut ::core::ffi::c_void;
pub type IPrinterScriptablePropertyBag = *mut ::core::ffi::c_void;
pub type IPrinterScriptablePropertyBag2 = *mut ::core::ffi::c_void;
pub type IPrinterScriptableSequentialStream = *mut ::core::ffi::c_void;
pub type IPrinterScriptableStream = *mut ::core::ffi::c_void;
#[repr(C)]
pub struct IXpsDocument {
pub lpVtbl: *mut IXpsDocumentVtbl,
}
impl ::core::marker::Copy for IXpsDocument {}
impl ::core::clone::Clone for IXpsDocument {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IXpsDocumentConsumer {
pub lpVtbl: *mut IXpsDocumentConsumerVtbl,
}
impl ::core::marker::Copy for IXpsDocumentConsumer {}
impl ::core::clone::Clone for IXpsDocumentConsumer {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IXpsDocumentConsumerVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub SendXpsUnknown: isize,
pub SendXpsDocument: isize,
pub SendFixedDocumentSequence: isize,
pub SendFixedDocument: isize,
pub SendFixedPage: isize,
pub CloseSender: isize,
pub GetNewEmptyPart: isize,
}
impl ::core::marker::Copy for IXpsDocumentConsumerVtbl {}
impl ::core::clone::Clone for IXpsDocumentConsumerVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IXpsDocumentProvider {
pub lpVtbl: *mut IXpsDocumentProviderVtbl,
}
impl ::core::marker::Copy for IXpsDocumentProvider {}
impl ::core::clone::Clone for IXpsDocumentProvider {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IXpsDocumentProviderVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetXpsPart: isize,
}
impl ::core::marker::Copy for IXpsDocumentProviderVtbl {}
impl ::core::clone::Clone for IXpsDocumentProviderVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IXpsDocumentVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub GetThumbnail: isize,
pub SetThumbnail: isize,
}
impl ::core::marker::Copy for IXpsDocumentVtbl {}
impl ::core::clone::Clone for IXpsDocumentVtbl {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IXpsPartIterator {
pub lpVtbl: *mut IXpsPartIteratorVtbl,
}
impl ::core::marker::Copy for IXpsPartIterator {}
impl ::core::clone::Clone for IXpsPartIterator {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct IXpsPartIteratorVtbl {
pub QueryInterface: isize,
pub AddRef: isize,
pub Release: isize,
pub Reset: isize,
pub Current: isize,
pub IsDone: isize,
pub Next: isize,
}
impl ::core::marker::Copy for IXpsPartIteratorVtbl {}
impl ::core::clone::Clone for IXpsPartIteratorVtbl {
fn clone(&self) -> Self {
*self
}
}
pub type IXpsRasterizationFactory = *mut ::core::ffi::c_void;
pub type IXpsRasterizationFactory1 = *mut ::core::ffi::c_void;
pub type IXpsRasterizationFactory2 = *mut ::core::ffi::c_void;
pub type IXpsRasterizer = *mut ::core::ffi::c_void;
pub type IXpsRasterizerNotificationCallback = *mut ::core::ffi::c_void;
pub const JOB_ACCESS_ADMINISTER: u32 = 16u32;
pub const JOB_ACCESS_READ: u32 = 32u32;
pub const JOB_CONTROL_CANCEL: u32 = 3u32;
pub const JOB_CONTROL_DELETE: u32 = 5u32;
pub const JOB_CONTROL_LAST_PAGE_EJECTED: u32 = 7u32;
pub const JOB_CONTROL_PAUSE: u32 = 1u32;
pub const JOB_CONTROL_RELEASE: u32 = 9u32;
pub const JOB_CONTROL_RESTART: u32 = 4u32;
pub const JOB_CONTROL_RESUME: u32 = 2u32;
pub const JOB_CONTROL_RETAIN: u32 = 8u32;
pub const JOB_CONTROL_SENT_TO_PRINTER: u32 = 6u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct JOB_INFO_1A {
pub JobId: u32,
pub pPrinterName: super::super::Foundation::PSTR,
pub pMachineName: super::super::Foundation::PSTR,
pub pUserName: super::super::Foundation::PSTR,
pub pDocument: super::super::Foundation::PSTR,
pub pDatatype: super::super::Foundation::PSTR,
pub pStatus: super::super::Foundation::PSTR,
pub Status: u32,
pub Priority: u32,
pub Position: u32,
pub TotalPages: u32,
pub PagesPrinted: u32,
pub Submitted: super::super::Foundation::SYSTEMTIME,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for JOB_INFO_1A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for JOB_INFO_1A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct JOB_INFO_1W {
pub JobId: u32,
pub pPrinterName: super::super::Foundation::PWSTR,
pub pMachineName: super::super::Foundation::PWSTR,
pub pUserName: super::super::Foundation::PWSTR,
pub pDocument: super::super::Foundation::PWSTR,
pub pDatatype: super::super::Foundation::PWSTR,
pub pStatus: super::super::Foundation::PWSTR,
pub Status: u32,
pub Priority: u32,
pub Position: u32,
pub TotalPages: u32,
pub PagesPrinted: u32,
pub Submitted: super::super::Foundation::SYSTEMTIME,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for JOB_INFO_1W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for JOB_INFO_1W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
pub struct JOB_INFO_2A {
pub JobId: u32,
pub pPrinterName: super::super::Foundation::PSTR,
pub pMachineName: super::super::Foundation::PSTR,
pub pUserName: super::super::Foundation::PSTR,
pub pDocument: super::super::Foundation::PSTR,
pub pNotifyName: super::super::Foundation::PSTR,
pub pDatatype: super::super::Foundation::PSTR,
pub pPrintProcessor: super::super::Foundation::PSTR,
pub pParameters: super::super::Foundation::PSTR,
pub pDriverName: super::super::Foundation::PSTR,
pub pDevMode: *mut super::Gdi::DEVMODEA,
pub pStatus: super::super::Foundation::PSTR,
pub pSecurityDescriptor: *mut super::super::Security::SECURITY_DESCRIPTOR,
pub Status: u32,
pub Priority: u32,
pub Position: u32,
pub StartTime: u32,
pub UntilTime: u32,
pub TotalPages: u32,
pub Size: u32,
pub Submitted: super::super::Foundation::SYSTEMTIME,
pub Time: u32,
pub PagesPrinted: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
impl ::core::marker::Copy for JOB_INFO_2A {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
impl ::core::clone::Clone for JOB_INFO_2A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
pub struct JOB_INFO_2W {
pub JobId: u32,
pub pPrinterName: super::super::Foundation::PWSTR,
pub pMachineName: super::super::Foundation::PWSTR,
pub pUserName: super::super::Foundation::PWSTR,
pub pDocument: super::super::Foundation::PWSTR,
pub pNotifyName: super::super::Foundation::PWSTR,
pub pDatatype: super::super::Foundation::PWSTR,
pub pPrintProcessor: super::super::Foundation::PWSTR,
pub pParameters: super::super::Foundation::PWSTR,
pub pDriverName: super::super::Foundation::PWSTR,
pub pDevMode: *mut super::Gdi::DEVMODEW,
pub pStatus: super::super::Foundation::PWSTR,
pub pSecurityDescriptor: *mut super::super::Security::SECURITY_DESCRIPTOR,
pub Status: u32,
pub Priority: u32,
pub Position: u32,
pub StartTime: u32,
pub UntilTime: u32,
pub TotalPages: u32,
pub Size: u32,
pub Submitted: super::super::Foundation::SYSTEMTIME,
pub Time: u32,
pub PagesPrinted: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
impl ::core::marker::Copy for JOB_INFO_2W {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
impl ::core::clone::Clone for JOB_INFO_2W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct JOB_INFO_3 {
pub JobId: u32,
pub NextJobId: u32,
pub Reserved: u32,
}
impl ::core::marker::Copy for JOB_INFO_3 {}
impl ::core::clone::Clone for JOB_INFO_3 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
pub struct JOB_INFO_4A {
pub JobId: u32,
pub pPrinterName: super::super::Foundation::PSTR,
pub pMachineName: super::super::Foundation::PSTR,
pub pUserName: super::super::Foundation::PSTR,
pub pDocument: super::super::Foundation::PSTR,
pub pNotifyName: super::super::Foundation::PSTR,
pub pDatatype: super::super::Foundation::PSTR,
pub pPrintProcessor: super::super::Foundation::PSTR,
pub pParameters: super::super::Foundation::PSTR,
pub pDriverName: super::super::Foundation::PSTR,
pub pDevMode: *mut super::Gdi::DEVMODEA,
pub pStatus: super::super::Foundation::PSTR,
pub pSecurityDescriptor: *mut super::super::Security::SECURITY_DESCRIPTOR,
pub Status: u32,
pub Priority: u32,
pub Position: u32,
pub StartTime: u32,
pub UntilTime: u32,
pub TotalPages: u32,
pub Size: u32,
pub Submitted: super::super::Foundation::SYSTEMTIME,
pub Time: u32,
pub PagesPrinted: u32,
pub SizeHigh: i32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
impl ::core::marker::Copy for JOB_INFO_4A {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
impl ::core::clone::Clone for JOB_INFO_4A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
pub struct JOB_INFO_4W {
pub JobId: u32,
pub pPrinterName: super::super::Foundation::PWSTR,
pub pMachineName: super::super::Foundation::PWSTR,
pub pUserName: super::super::Foundation::PWSTR,
pub pDocument: super::super::Foundation::PWSTR,
pub pNotifyName: super::super::Foundation::PWSTR,
pub pDatatype: super::super::Foundation::PWSTR,
pub pPrintProcessor: super::super::Foundation::PWSTR,
pub pParameters: super::super::Foundation::PWSTR,
pub pDriverName: super::super::Foundation::PWSTR,
pub pDevMode: *mut super::Gdi::DEVMODEW,
pub pStatus: super::super::Foundation::PWSTR,
pub pSecurityDescriptor: *mut super::super::Security::SECURITY_DESCRIPTOR,
pub Status: u32,
pub Priority: u32,
pub Position: u32,
pub StartTime: u32,
pub UntilTime: u32,
pub TotalPages: u32,
pub Size: u32,
pub Submitted: super::super::Foundation::SYSTEMTIME,
pub Time: u32,
pub PagesPrinted: u32,
pub SizeHigh: i32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
impl ::core::marker::Copy for JOB_INFO_4W {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
impl ::core::clone::Clone for JOB_INFO_4W {
fn clone(&self) -> Self {
*self
}
}
pub const JOB_NOTIFY_FIELD_BYTES_PRINTED: u32 = 23u32;
pub const JOB_NOTIFY_FIELD_DATATYPE: u32 = 5u32;
pub const JOB_NOTIFY_FIELD_DEVMODE: u32 = 9u32;
pub const JOB_NOTIFY_FIELD_DOCUMENT: u32 = 13u32;
pub const JOB_NOTIFY_FIELD_DRIVER_NAME: u32 = 8u32;
pub const JOB_NOTIFY_FIELD_MACHINE_NAME: u32 = 1u32;
pub const JOB_NOTIFY_FIELD_NOTIFY_NAME: u32 = 4u32;
pub const JOB_NOTIFY_FIELD_PAGES_PRINTED: u32 = 21u32;
pub const JOB_NOTIFY_FIELD_PARAMETERS: u32 = 7u32;
pub const JOB_NOTIFY_FIELD_PORT_NAME: u32 = 2u32;
pub const JOB_NOTIFY_FIELD_POSITION: u32 = 15u32;
pub const JOB_NOTIFY_FIELD_PRINTER_NAME: u32 = 0u32;
pub const JOB_NOTIFY_FIELD_PRINT_PROCESSOR: u32 = 6u32;
pub const JOB_NOTIFY_FIELD_PRIORITY: u32 = 14u32;
pub const JOB_NOTIFY_FIELD_REMOTE_JOB_ID: u32 = 24u32;
pub const JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: u32 = 12u32;
pub const JOB_NOTIFY_FIELD_START_TIME: u32 = 17u32;
pub const JOB_NOTIFY_FIELD_STATUS: u32 = 10u32;
pub const JOB_NOTIFY_FIELD_STATUS_STRING: u32 = 11u32;
pub const JOB_NOTIFY_FIELD_SUBMITTED: u32 = 16u32;
pub const JOB_NOTIFY_FIELD_TIME: u32 = 19u32;
pub const JOB_NOTIFY_FIELD_TOTAL_BYTES: u32 = 22u32;
pub const JOB_NOTIFY_FIELD_TOTAL_PAGES: u32 = 20u32;
pub const JOB_NOTIFY_FIELD_UNTIL_TIME: u32 = 18u32;
pub const JOB_NOTIFY_FIELD_USER_NAME: u32 = 3u32;
pub const JOB_NOTIFY_TYPE: u32 = 1u32;
pub const JOB_POSITION_UNSPECIFIED: u32 = 0u32;
pub const JOB_STATUS_BLOCKED_DEVQ: u32 = 512u32;
pub const JOB_STATUS_COMPLETE: u32 = 4096u32;
pub const JOB_STATUS_DELETED: u32 = 256u32;
pub const JOB_STATUS_DELETING: u32 = 4u32;
pub const JOB_STATUS_ERROR: u32 = 2u32;
pub const JOB_STATUS_OFFLINE: u32 = 32u32;
pub const JOB_STATUS_PAPEROUT: u32 = 64u32;
pub const JOB_STATUS_PAUSED: u32 = 1u32;
pub const JOB_STATUS_PRINTED: u32 = 128u32;
pub const JOB_STATUS_PRINTING: u32 = 16u32;
pub const JOB_STATUS_RENDERING_LOCALLY: u32 = 16384u32;
pub const JOB_STATUS_RESTART: u32 = 2048u32;
pub const JOB_STATUS_RETAINED: u32 = 8192u32;
pub const JOB_STATUS_SPOOLING: u32 = 8u32;
pub const JOB_STATUS_USER_INTERVENTION: u32 = 1024u32;
#[repr(C)]
#[cfg(feature = "Win32_Devices_Display")]
pub struct KERNDATA {
pub dwSize: u32,
pub dwKernPairNum: u32,
pub KernPair: [super::super::Devices::Display::FD_KERNINGPAIR; 1],
}
#[cfg(feature = "Win32_Devices_Display")]
impl ::core::marker::Copy for KERNDATA {}
#[cfg(feature = "Win32_Devices_Display")]
impl ::core::clone::Clone for KERNDATA {
fn clone(&self) -> Self {
*self
}
}
pub const LPR: u32 = 2u32;
#[repr(C)]
pub struct MAPTABLE {
pub dwSize: u32,
pub dwGlyphNum: u32,
pub Trans: [TRANSDATA; 1],
}
impl ::core::marker::Copy for MAPTABLE {}
impl ::core::clone::Clone for MAPTABLE {
fn clone(&self) -> Self {
*self
}
}
pub const MAX_ADDRESS_STR_LEN: u32 = 13u32;
pub const MAX_CPSFUNC_INDEX: u32 = 26u32;
pub const MAX_DEVICEDESCRIPTION_STR_LEN: u32 = 257u32;
pub const MAX_DLGPAGE_COUNT: u32 = 64u32;
pub const MAX_FORM_KEYWORD_LENGTH: u32 = 64u32;
pub const MAX_IPADDR_STR_LEN: u32 = 16u32;
pub const MAX_NETWORKNAME2_LEN: u32 = 128u32;
pub const MAX_NETWORKNAME_LEN: u32 = 49u32;
pub const MAX_PORTNAME_LEN: u32 = 64u32;
pub const MAX_PRIORITY: u32 = 99u32;
pub const MAX_PROPSHEETUI_REASON_INDEX: u32 = 5u32;
pub const MAX_PSUIPAGEINSERT_INDEX: u32 = 5u32;
pub const MAX_QUEUENAME_LEN: u32 = 33u32;
pub const MAX_RES_STR_CHARS: u32 = 160u32;
pub const MAX_SNMP_COMMUNITY_STR_LEN: u32 = 33u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MESSAGEBOX_PARAMS {
pub cbSize: u32,
pub pTitle: super::super::Foundation::PWSTR,
pub pMessage: super::super::Foundation::PWSTR,
pub Style: u32,
pub dwTimeout: u32,
pub bWait: super::super::Foundation::BOOL,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for MESSAGEBOX_PARAMS {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for MESSAGEBOX_PARAMS {
fn clone(&self) -> Self {
*self
}
}
pub const MIN_PRIORITY: u32 = 1u32;
#[repr(C)]
pub struct MONITOR {
pub pfnEnumPorts: isize,
pub pfnOpenPort: isize,
pub pfnOpenPortEx: isize,
pub pfnStartDocPort: isize,
pub pfnWritePort: isize,
pub pfnReadPort: isize,
pub pfnEndDocPort: isize,
pub pfnClosePort: isize,
pub pfnAddPort: isize,
pub pfnAddPortEx: isize,
pub pfnConfigurePort: isize,
pub pfnDeletePort: isize,
pub pfnGetPrinterDataFromPort: isize,
pub pfnSetPortTimeOuts: isize,
pub pfnXcvOpenPort: isize,
pub pfnXcvDataPort: isize,
pub pfnXcvClosePort: isize,
}
impl ::core::marker::Copy for MONITOR {}
impl ::core::clone::Clone for MONITOR {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct MONITOR2 {
pub cbSize: u32,
pub pfnEnumPorts: isize,
pub pfnOpenPort: isize,
pub pfnOpenPortEx: isize,
pub pfnStartDocPort: isize,
pub pfnWritePort: isize,
pub pfnReadPort: isize,
pub pfnEndDocPort: isize,
pub pfnClosePort: isize,
pub pfnAddPort: isize,
pub pfnAddPortEx: isize,
pub pfnConfigurePort: isize,
pub pfnDeletePort: isize,
pub pfnGetPrinterDataFromPort: isize,
pub pfnSetPortTimeOuts: isize,
pub pfnXcvOpenPort: isize,
pub pfnXcvDataPort: isize,
pub pfnXcvClosePort: isize,
pub pfnShutdown: isize,
pub pfnSendRecvBidiDataFromPort: isize,
pub pfnNotifyUsedPorts: isize,
pub pfnNotifyUnusedPorts: isize,
pub pfnPowerEvent: isize,
}
impl ::core::marker::Copy for MONITOR2 {}
impl ::core::clone::Clone for MONITOR2 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct MONITOREX {
pub dwMonitorSize: u32,
pub Monitor: MONITOR,
}
impl ::core::marker::Copy for MONITOREX {}
impl ::core::clone::Clone for MONITOREX {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
pub struct MONITORINIT {
pub cbSize: u32,
pub hSpooler: super::super::Foundation::HANDLE,
pub hckRegistryRoot: super::super::System::Registry::HKEY,
pub pMonitorReg: *mut MONITORREG,
pub bLocal: super::super::Foundation::BOOL,
pub pszServerName: super::super::Foundation::PWSTR,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
impl ::core::marker::Copy for MONITORINIT {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
impl ::core::clone::Clone for MONITORINIT {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct MONITORREG {
pub cbSize: u32,
pub fpCreateKey: isize,
pub fpOpenKey: isize,
pub fpCloseKey: isize,
pub fpDeleteKey: isize,
pub fpEnumKey: isize,
pub fpQueryInfoKey: isize,
pub fpSetValue: isize,
pub fpDeleteValue: isize,
pub fpEnumValue: isize,
pub fpQueryValue: isize,
}
impl ::core::marker::Copy for MONITORREG {}
impl ::core::clone::Clone for MONITORREG {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct MONITORUI {
pub dwMonitorUISize: u32,
pub pfnAddPortUI: isize,
pub pfnConfigurePortUI: isize,
pub pfnDeletePortUI: isize,
}
impl ::core::marker::Copy for MONITORUI {}
impl ::core::clone::Clone for MONITORUI {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MONITOR_INFO_1A {
pub pName: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for MONITOR_INFO_1A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for MONITOR_INFO_1A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MONITOR_INFO_1W {
pub pName: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for MONITOR_INFO_1W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for MONITOR_INFO_1W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MONITOR_INFO_2A {
pub pName: super::super::Foundation::PSTR,
pub pEnvironment: super::super::Foundation::PSTR,
pub pDLLName: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for MONITOR_INFO_2A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for MONITOR_INFO_2A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct MONITOR_INFO_2W {
pub pName: super::super::Foundation::PWSTR,
pub pEnvironment: super::super::Foundation::PWSTR,
pub pDLLName: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for MONITOR_INFO_2W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for MONITOR_INFO_2W {
fn clone(&self) -> Self {
*self
}
}
pub const MTYPE_ADD: u32 = 64u32;
pub const MTYPE_COMPOSE: u32 = 1u32;
pub const MTYPE_DIRECT: u32 = 2u32;
pub const MTYPE_DISABLE: u32 = 128u32;
pub const MTYPE_DOUBLE: u32 = 16u32;
pub const MTYPE_DOUBLEBYTECHAR_MASK: u32 = 24u32;
pub const MTYPE_FORMAT_MASK: u32 = 7u32;
pub const MTYPE_PAIRED: u32 = 4u32;
pub const MTYPE_PREDEFIN_MASK: u32 = 224u32;
pub const MTYPE_REPLACE: u32 = 32u32;
pub const MTYPE_SINGLE: u32 = 8u32;
pub const MV_GRAPHICS: u32 = 4u32;
pub const MV_PHYSICAL: u32 = 8u32;
pub const MV_RELATIVE: u32 = 2u32;
pub const MV_SENDXMOVECMD: u32 = 16u32;
pub const MV_SENDYMOVECMD: u32 = 32u32;
pub const MV_UPDATE: u32 = 1u32;
pub const MXDCOP_GET_FILENAME: u32 = 14u32;
pub const MXDCOP_PRINTTICKET_FIXED_DOC: u32 = 24u32;
pub const MXDCOP_PRINTTICKET_FIXED_DOC_SEQ: u32 = 22u32;
pub const MXDCOP_PRINTTICKET_FIXED_PAGE: u32 = 26u32;
pub const MXDCOP_SET_S0PAGE: u32 = 28u32;
pub const MXDCOP_SET_S0PAGE_RESOURCE: u32 = 30u32;
pub const MXDCOP_SET_XPSPASSTHRU_MODE: u32 = 32u32;
pub const MXDC_ESCAPE: u32 = 4122u32;
#[repr(C, packed(1))]
pub struct MxdcEscapeHeader {
pub cbInput: u32,
pub cbOutput: u32,
pub opCode: u32,
}
impl ::core::marker::Copy for MxdcEscapeHeader {}
impl ::core::clone::Clone for MxdcEscapeHeader {
fn clone(&self) -> Self {
*self
}
}
#[repr(C, packed(1))]
pub struct MxdcGetFileNameData {
pub cbOutput: u32,
pub wszData: [u16; 1],
}
impl ::core::marker::Copy for MxdcGetFileNameData {}
impl ::core::clone::Clone for MxdcGetFileNameData {
fn clone(&self) -> Self {
*self
}
}
pub type MxdcImageTypeEnums = i32;
pub const MXDC_IMAGETYPE_JPEGHIGH_COMPRESSION: MxdcImageTypeEnums = 1i32;
pub const MXDC_IMAGETYPE_JPEGMEDIUM_COMPRESSION: MxdcImageTypeEnums = 2i32;
pub const MXDC_IMAGETYPE_JPEGLOW_COMPRESSION: MxdcImageTypeEnums = 3i32;
pub const MXDC_IMAGETYPE_PNG: MxdcImageTypeEnums = 4i32;
pub type MxdcLandscapeRotationEnums = i32;
pub const MXDC_LANDSCAPE_ROTATE_COUNTERCLOCKWISE_90_DEGREES: MxdcLandscapeRotationEnums = 90i32;
pub const MXDC_LANDSCAPE_ROTATE_NONE: MxdcLandscapeRotationEnums = 0i32;
pub const MXDC_LANDSCAPE_ROTATE_COUNTERCLOCKWISE_270_DEGREES: MxdcLandscapeRotationEnums = -90i32;
#[repr(C)]
pub struct MxdcPrintTicketEscape {
pub mxdcEscape: MxdcEscapeHeader,
pub printTicketData: MxdcPrintTicketPassthrough,
}
impl ::core::marker::Copy for MxdcPrintTicketEscape {}
impl ::core::clone::Clone for MxdcPrintTicketEscape {
fn clone(&self) -> Self {
*self
}
}
#[repr(C, packed(1))]
pub struct MxdcPrintTicketPassthrough {
pub dwDataSize: u32,
pub bData: [u8; 1],
}
impl ::core::marker::Copy for MxdcPrintTicketPassthrough {}
impl ::core::clone::Clone for MxdcPrintTicketPassthrough {
fn clone(&self) -> Self {
*self
}
}
#[repr(C, packed(1))]
pub struct MxdcS0PageData {
pub dwSize: u32,
pub bData: [u8; 1],
}
impl ::core::marker::Copy for MxdcS0PageData {}
impl ::core::clone::Clone for MxdcS0PageData {
fn clone(&self) -> Self {
*self
}
}
pub type MxdcS0PageEnums = i32;
pub const MXDC_RESOURCE_TTF: MxdcS0PageEnums = 0i32;
pub const MXDC_RESOURCE_JPEG: MxdcS0PageEnums = 1i32;
pub const MXDC_RESOURCE_PNG: MxdcS0PageEnums = 2i32;
pub const MXDC_RESOURCE_TIFF: MxdcS0PageEnums = 3i32;
pub const MXDC_RESOURCE_WDP: MxdcS0PageEnums = 4i32;
pub const MXDC_RESOURCE_DICTIONARY: MxdcS0PageEnums = 5i32;
pub const MXDC_RESOURCE_ICC_PROFILE: MxdcS0PageEnums = 6i32;
pub const MXDC_RESOURCE_JPEG_THUMBNAIL: MxdcS0PageEnums = 7i32;
pub const MXDC_RESOURCE_PNG_THUMBNAIL: MxdcS0PageEnums = 8i32;
pub const MXDC_RESOURCE_MAX: MxdcS0PageEnums = 9i32;
#[repr(C)]
pub struct MxdcS0PagePassthroughEscape {
pub mxdcEscape: MxdcEscapeHeader,
pub xpsS0PageData: MxdcS0PageData,
}
impl ::core::marker::Copy for MxdcS0PagePassthroughEscape {}
impl ::core::clone::Clone for MxdcS0PagePassthroughEscape {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct MxdcS0PageResourceEscape {
pub mxdcEscape: MxdcEscapeHeader,
pub xpsS0PageResourcePassthrough: MxdcXpsS0PageResource,
}
impl ::core::marker::Copy for MxdcS0PageResourceEscape {}
impl ::core::clone::Clone for MxdcS0PageResourceEscape {
fn clone(&self) -> Self {
*self
}
}
#[repr(C, packed(1))]
pub struct MxdcXpsS0PageResource {
pub dwSize: u32,
pub dwResourceType: u32,
pub szUri: [u8; 260],
pub dwDataSize: u32,
pub bData: [u8; 1],
}
impl ::core::marker::Copy for MxdcXpsS0PageResource {}
impl ::core::clone::Clone for MxdcXpsS0PageResource {
fn clone(&self) -> Self {
*self
}
}
pub const NORMAL_PRINT: u32 = 0u32;
pub type NOTIFICATION_CALLBACK_COMMANDS = i32;
pub const NOTIFICATION_COMMAND_NOTIFY: NOTIFICATION_CALLBACK_COMMANDS = 0i32;
pub const NOTIFICATION_COMMAND_CONTEXT_ACQUIRE: NOTIFICATION_CALLBACK_COMMANDS = 1i32;
pub const NOTIFICATION_COMMAND_CONTEXT_RELEASE: NOTIFICATION_CALLBACK_COMMANDS = 2i32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct NOTIFICATION_CONFIG_1 {
pub cbSize: u32,
pub fdwFlags: u32,
pub pfnNotifyCallback: ROUTER_NOTIFY_CALLBACK,
pub pContext: *mut ::core::ffi::c_void,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for NOTIFICATION_CONFIG_1 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for NOTIFICATION_CONFIG_1 {
fn clone(&self) -> Self {
*self
}
}
pub type NOTIFICATION_CONFIG_FLAGS = i32;
pub const NOTIFICATION_CONFIG_CREATE_EVENT: NOTIFICATION_CONFIG_FLAGS = 1i32;
pub const NOTIFICATION_CONFIG_REGISTER_CALLBACK: NOTIFICATION_CONFIG_FLAGS = 2i32;
pub const NOTIFICATION_CONFIG_EVENT_TRIGGER: NOTIFICATION_CONFIG_FLAGS = 4i32;
pub const NOTIFICATION_CONFIG_ASYNC_CHANNEL: NOTIFICATION_CONFIG_FLAGS = 8i32;
pub const NOTIFICATION_RELEASE: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 3130675239, data2: 42766, data3: 19175, data4: [155, 125, 235, 62, 6, 173, 65, 87] };
pub const NO_BORDER_PRINT: u32 = 1u32;
pub const NO_COLOR_OPTIMIZATION: u32 = 0u32;
pub const NO_PRIORITY: u32 = 0u32;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_UI_WindowsAndMessaging"))]
pub type OEMCUIPCALLBACK = ::core::option::Option<unsafe extern "system" fn(param0: *mut CPSUICBPARAM, param1: *mut OEMCUIPPARAM) -> i32>;
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_UI_WindowsAndMessaging"))]
pub struct OEMCUIPPARAM {
pub cbSize: u32,
pub poemuiobj: *mut OEMUIOBJ,
pub hPrinter: super::super::Foundation::HANDLE,
pub pPrinterName: super::super::Foundation::PWSTR,
pub hModule: super::super::Foundation::HANDLE,
pub hOEMHeap: super::super::Foundation::HANDLE,
pub pPublicDM: *mut super::Gdi::DEVMODEA,
pub pOEMDM: *mut ::core::ffi::c_void,
pub dwFlags: u32,
pub pDrvOptItems: *mut OPTITEM,
pub cDrvOptItems: u32,
pub pOEMOptItems: *mut OPTITEM,
pub cOEMOptItems: u32,
pub pOEMUserData: *mut ::core::ffi::c_void,
pub OEMCUIPCallback: OEMCUIPCALLBACK,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for OEMCUIPPARAM {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for OEMCUIPPARAM {
fn clone(&self) -> Self {
*self
}
}
pub const OEMCUIP_DOCPROP: u32 = 1u32;
pub const OEMCUIP_PRNPROP: u32 = 2u32;
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub struct OEMDMPARAM {
pub cbSize: u32,
pub pdriverobj: *mut ::core::ffi::c_void,
pub hPrinter: super::super::Foundation::HANDLE,
pub hModule: super::super::Foundation::HANDLE,
pub pPublicDMIn: *mut super::Gdi::DEVMODEA,
pub pPublicDMOut: *mut super::Gdi::DEVMODEA,
pub pOEMDMIn: *mut ::core::ffi::c_void,
pub pOEMDMOut: *mut ::core::ffi::c_void,
pub cbBufSize: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::marker::Copy for OEMDMPARAM {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for OEMDMPARAM {
fn clone(&self) -> Self {
*self
}
}
pub const OEMDM_CONVERT: u32 = 3u32;
pub const OEMDM_DEFAULT: u32 = 2u32;
pub const OEMDM_MERGE: u32 = 4u32;
pub const OEMDM_SIZE: u32 = 1u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct OEMFONTINSTPARAM {
pub cbSize: u32,
pub hPrinter: super::super::Foundation::HANDLE,
pub hModule: super::super::Foundation::HANDLE,
pub hHeap: super::super::Foundation::HANDLE,
pub dwFlags: u32,
pub pFontInstallerName: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for OEMFONTINSTPARAM {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for OEMFONTINSTPARAM {
fn clone(&self) -> Self {
*self
}
}
pub const OEMGDS_FREEMEM: u32 = 32769u32;
pub const OEMGDS_JOBTIMEOUT: u32 = 32770u32;
pub const OEMGDS_MAX: u32 = 65536u32;
pub const OEMGDS_MAXBITMAP: u32 = 32774u32;
pub const OEMGDS_MINOUTLINE: u32 = 32773u32;
pub const OEMGDS_MIN_DOCSTICKY: u32 = 1u32;
pub const OEMGDS_MIN_PRINTERSTICKY: u32 = 32768u32;
pub const OEMGDS_PRINTFLAGS: u32 = 32768u32;
pub const OEMGDS_PROTOCOL: u32 = 32772u32;
pub const OEMGDS_PSDM_CUSTOMSIZE: u32 = 6u32;
pub const OEMGDS_PSDM_DIALECT: u32 = 2u32;
pub const OEMGDS_PSDM_FLAGS: u32 = 1u32;
pub const OEMGDS_PSDM_NUP: u32 = 4u32;
pub const OEMGDS_PSDM_PSLEVEL: u32 = 5u32;
pub const OEMGDS_PSDM_TTDLFMT: u32 = 3u32;
pub const OEMGDS_UNIDM_FLAGS: u32 = 16385u32;
pub const OEMGDS_UNIDM_GPDVER: u32 = 16384u32;
pub const OEMGDS_WAITTIMEOUT: u32 = 32771u32;
pub const OEMGI_GETINTERFACEVERSION: u32 = 2u32;
pub const OEMGI_GETPUBLISHERINFO: u32 = 4u32;
pub const OEMGI_GETREQUESTEDHELPERINTERFACES: u32 = 5u32;
pub const OEMGI_GETSIGNATURE: u32 = 1u32;
pub const OEMGI_GETVERSION: u32 = 3u32;
pub const OEMPUBLISH_DEFAULT: u32 = 0u32;
pub const OEMPUBLISH_IPRINTCOREHELPER: u32 = 1u32;
pub const OEMTTY_INFO_CODEPAGE: u32 = 2u32;
pub const OEMTTY_INFO_MARGINS: u32 = 1u32;
pub const OEMTTY_INFO_NUM_UFMS: u32 = 3u32;
pub const OEMTTY_INFO_UFM_IDS: u32 = 4u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct OEMUIOBJ {
pub cbSize: u32,
pub pOemUIProcs: *mut OEMUIPROCS,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for OEMUIOBJ {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for OEMUIOBJ {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct OEMUIPROCS {
pub DrvGetDriverSetting: PFN_DrvGetDriverSetting,
pub DrvUpdateUISetting: PFN_DrvUpdateUISetting,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for OEMUIPROCS {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for OEMUIPROCS {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub struct OEMUIPSPARAM {
pub cbSize: u32,
pub poemuiobj: *mut OEMUIOBJ,
pub hPrinter: super::super::Foundation::HANDLE,
pub pPrinterName: super::super::Foundation::PWSTR,
pub hModule: super::super::Foundation::HANDLE,
pub hOEMHeap: super::super::Foundation::HANDLE,
pub pPublicDM: *mut super::Gdi::DEVMODEA,
pub pOEMDM: *mut ::core::ffi::c_void,
pub pOEMUserData: *mut ::core::ffi::c_void,
pub dwFlags: u32,
pub pOemEntry: *mut ::core::ffi::c_void,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::marker::Copy for OEMUIPSPARAM {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for OEMUIPSPARAM {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct OEM_DMEXTRAHEADER {
pub dwSize: u32,
pub dwSignature: u32,
pub dwVersion: u32,
}
impl ::core::marker::Copy for OEM_DMEXTRAHEADER {}
impl ::core::clone::Clone for OEM_DMEXTRAHEADER {
fn clone(&self) -> Self {
*self
}
}
pub const OEM_MODE_PUBLISHER: u32 = 1u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct OIEXT {
pub cbSize: u16,
pub Flags: u16,
pub hInstCaller: super::super::Foundation::HINSTANCE,
pub pHelpFile: *mut i8,
pub dwReserved: [usize; 4],
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for OIEXT {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for OIEXT {
fn clone(&self) -> Self {
*self
}
}
pub const OIEXTF_ANSI_STRING: u32 = 1u32;
pub const OPTCF_HIDE: u32 = 1u32;
pub const OPTCF_MASK: u32 = 1u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct OPTCOMBO {
pub cbSize: u16,
pub Flags: u8,
pub cListItem: u16,
pub pListItem: *mut OPTPARAM,
pub Sel: i32,
pub dwReserved: [u32; 3],
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for OPTCOMBO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for OPTCOMBO {
fn clone(&self) -> Self {
*self
}
}
pub const OPTIF_CALLBACK: i32 = 4i32;
pub const OPTIF_CHANGED: i32 = 8i32;
pub const OPTIF_CHANGEONCE: i32 = 16i32;
pub const OPTIF_COLLAPSE: i32 = 1i32;
pub const OPTIF_DISABLED: i32 = 32i32;
pub const OPTIF_ECB_CHECKED: i32 = 64i32;
pub const OPTIF_EXT_DISABLED: i32 = 256i32;
pub const OPTIF_EXT_HIDE: i32 = 128i32;
pub const OPTIF_EXT_IS_EXTPUSH: i32 = 1024i32;
pub const OPTIF_HAS_POIEXT: i32 = 65536i32;
pub const OPTIF_HIDE: i32 = 2i32;
pub const OPTIF_INITIAL_TVITEM: i32 = 32768i32;
pub const OPTIF_MASK: i32 = 131071i32;
pub const OPTIF_NO_GROUPBOX_NAME: i32 = 2048i32;
pub const OPTIF_OVERLAY_NO_ICON: i32 = 16384i32;
pub const OPTIF_OVERLAY_STOP_ICON: i32 = 8192i32;
pub const OPTIF_OVERLAY_WARNING_ICON: i32 = 4096i32;
pub const OPTIF_SEL_AS_HICON: i32 = 512i32;
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub struct OPTITEM {
pub cbSize: u16,
pub Level: u8,
pub DlgPageIdx: u8,
pub Flags: u32,
pub UserData: usize,
pub pName: *mut i8,
pub Anonymous1: OPTITEM_0,
pub Anonymous2: OPTITEM_1,
pub pOptType: *mut OPTTYPE,
pub HelpIndex: u32,
pub DMPubID: u8,
pub UserItemID: u8,
pub wReserved: u16,
pub pOIExt: *mut OIEXT,
pub dwReserved: [usize; 3],
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for OPTITEM {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for OPTITEM {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub union OPTITEM_0 {
pub Sel: i32,
pub pSel: *mut i8,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for OPTITEM_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for OPTITEM_0 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub union OPTITEM_1 {
pub pExtChkBox: *mut EXTCHKBOX,
pub pExtPush: *mut EXTPUSH,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for OPTITEM_1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for OPTITEM_1 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct OPTPARAM {
pub cbSize: u16,
pub Flags: u8,
pub Style: u8,
pub pData: *mut i8,
pub IconID: usize,
pub lParam: super::super::Foundation::LPARAM,
pub dwReserved: [usize; 2],
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for OPTPARAM {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for OPTPARAM {
fn clone(&self) -> Self {
*self
}
}
pub const OPTPF_DISABLED: u32 = 2u32;
pub const OPTPF_HIDE: u32 = 1u32;
pub const OPTPF_ICONID_AS_HICON: u32 = 4u32;
pub const OPTPF_MASK: u32 = 127u32;
pub const OPTPF_OVERLAY_NO_ICON: u32 = 32u32;
pub const OPTPF_OVERLAY_STOP_ICON: u32 = 16u32;
pub const OPTPF_OVERLAY_WARNING_ICON: u32 = 8u32;
pub const OPTPF_USE_HDLGTEMPLATE: u32 = 64u32;
pub const OPTTF_MASK: u32 = 3u32;
pub const OPTTF_NOSPACE_BEFORE_POSTFIX: u32 = 2u32;
pub const OPTTF_TYPE_DISABLED: u32 = 1u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct OPTTYPE {
pub cbSize: u16,
pub Type: u8,
pub Flags: u8,
pub Count: u16,
pub BegCtrlID: u16,
pub pOptParam: *mut OPTPARAM,
pub Style: u16,
pub wReserved: [u16; 3],
pub dwReserved: [usize; 3],
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for OPTTYPE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for OPTTYPE {
fn clone(&self) -> Self {
*self
}
}
pub const OTS_LBCB_INCL_ITEM_NONE: u32 = 8u32;
pub const OTS_LBCB_NO_ICON16_IN_ITEM: u32 = 16u32;
pub const OTS_LBCB_PROPPAGE_CBUSELB: u32 = 4u32;
pub const OTS_LBCB_PROPPAGE_LBUSECB: u32 = 2u32;
pub const OTS_LBCB_SORT: u32 = 1u32;
pub const OTS_MASK: u32 = 255u32;
pub const OTS_PUSH_ENABLE_ALWAYS: u32 = 128u32;
pub const OTS_PUSH_INCL_SETUP_TITLE: u32 = 32u32;
pub const OTS_PUSH_NO_DOT_DOT_DOT: u32 = 64u32;
pub const PDEV_ADJUST_PAPER_MARGIN_TYPE: u32 = 1u32;
pub const PDEV_HOSTFONT_ENABLED_TYPE: u32 = 2u32;
pub const PDEV_USE_TRUE_COLOR_TYPE: u32 = 3u32;
#[cfg(feature = "Win32_Foundation")]
pub type PFNCOMPROPSHEET = ::core::option::Option<unsafe extern "system" fn(hcompropsheet: super::super::Foundation::HANDLE, function: u32, lparam1: super::super::Foundation::LPARAM, lparam2: super::super::Foundation::LPARAM) -> isize>;
#[cfg(feature = "Win32_Foundation")]
pub type PFNPROPSHEETUI = ::core::option::Option<unsafe extern "system" fn(ppsuiinfo: *mut PROPSHEETUI_INFO, lparam: super::super::Foundation::LPARAM) -> i32>;
#[cfg(feature = "Win32_Foundation")]
pub type PFN_DrvGetDriverSetting = ::core::option::Option<unsafe extern "system" fn(pdriverobj: *mut ::core::ffi::c_void, feature: super::super::Foundation::PSTR, poutput: *mut ::core::ffi::c_void, cbsize: u32, pcbneeded: *mut u32, pdwoptionsreturned: *mut u32) -> super::super::Foundation::BOOL>;
#[cfg(feature = "Win32_Foundation")]
pub type PFN_DrvUpdateUISetting = ::core::option::Option<unsafe extern "system" fn(pdriverobj: *mut ::core::ffi::c_void, poptitem: *mut ::core::ffi::c_void, dwpreviousselection: u32, dwmode: u32) -> super::super::Foundation::BOOL>;
#[cfg(feature = "Win32_Foundation")]
pub type PFN_DrvUpgradeRegistrySetting = ::core::option::Option<unsafe extern "system" fn(hprinter: super::super::Foundation::HANDLE, pfeature: super::super::Foundation::PSTR, poption: super::super::Foundation::PSTR) -> super::super::Foundation::BOOL>;
#[repr(C)]
pub struct PORT_DATA_1 {
pub sztPortName: [u16; 64],
pub dwVersion: u32,
pub dwProtocol: u32,
pub cbSize: u32,
pub dwReserved: u32,
pub sztHostAddress: [u16; 49],
pub sztSNMPCommunity: [u16; 33],
pub dwDoubleSpool: u32,
pub sztQueue: [u16; 33],
pub sztIPAddress: [u16; 16],
pub Reserved: [u8; 540],
pub dwPortNumber: u32,
pub dwSNMPEnabled: u32,
pub dwSNMPDevIndex: u32,
}
impl ::core::marker::Copy for PORT_DATA_1 {}
impl ::core::clone::Clone for PORT_DATA_1 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct PORT_DATA_2 {
pub sztPortName: [u16; 64],
pub dwVersion: u32,
pub dwProtocol: u32,
pub cbSize: u32,
pub dwReserved: u32,
pub sztHostAddress: [u16; 128],
pub sztSNMPCommunity: [u16; 33],
pub dwDoubleSpool: u32,
pub sztQueue: [u16; 33],
pub Reserved: [u8; 514],
pub dwPortNumber: u32,
pub dwSNMPEnabled: u32,
pub dwSNMPDevIndex: u32,
pub dwPortMonitorMibIndex: u32,
}
impl ::core::marker::Copy for PORT_DATA_2 {}
impl ::core::clone::Clone for PORT_DATA_2 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct PORT_DATA_LIST_1 {
pub dwVersion: u32,
pub cPortData: u32,
pub pPortData: [PORT_DATA_2; 1],
}
impl ::core::marker::Copy for PORT_DATA_LIST_1 {}
impl ::core::clone::Clone for PORT_DATA_LIST_1 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PORT_INFO_1A {
pub pName: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PORT_INFO_1A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PORT_INFO_1A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PORT_INFO_1W {
pub pName: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PORT_INFO_1W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PORT_INFO_1W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PORT_INFO_2A {
pub pPortName: super::super::Foundation::PSTR,
pub pMonitorName: super::super::Foundation::PSTR,
pub pDescription: super::super::Foundation::PSTR,
pub fPortType: u32,
pub Reserved: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PORT_INFO_2A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PORT_INFO_2A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PORT_INFO_2W {
pub pPortName: super::super::Foundation::PWSTR,
pub pMonitorName: super::super::Foundation::PWSTR,
pub pDescription: super::super::Foundation::PWSTR,
pub fPortType: u32,
pub Reserved: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PORT_INFO_2W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PORT_INFO_2W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PORT_INFO_3A {
pub dwStatus: u32,
pub pszStatus: super::super::Foundation::PSTR,
pub dwSeverity: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PORT_INFO_3A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PORT_INFO_3A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PORT_INFO_3W {
pub dwStatus: u32,
pub pszStatus: super::super::Foundation::PWSTR,
pub dwSeverity: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PORT_INFO_3W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PORT_INFO_3W {
fn clone(&self) -> Self {
*self
}
}
pub const PORT_STATUS_DOOR_OPEN: u32 = 7u32;
pub const PORT_STATUS_NO_TONER: u32 = 6u32;
pub const PORT_STATUS_OFFLINE: u32 = 1u32;
pub const PORT_STATUS_OUTPUT_BIN_FULL: u32 = 4u32;
pub const PORT_STATUS_OUT_OF_MEMORY: u32 = 9u32;
pub const PORT_STATUS_PAPER_JAM: u32 = 2u32;
pub const PORT_STATUS_PAPER_OUT: u32 = 3u32;
pub const PORT_STATUS_PAPER_PROBLEM: u32 = 5u32;
pub const PORT_STATUS_POWER_SAVE: u32 = 12u32;
pub const PORT_STATUS_TONER_LOW: u32 = 10u32;
pub const PORT_STATUS_TYPE_ERROR: u32 = 1u32;
pub const PORT_STATUS_TYPE_INFO: u32 = 3u32;
pub const PORT_STATUS_TYPE_WARNING: u32 = 2u32;
pub const PORT_STATUS_USER_INTERVENTION: u32 = 8u32;
pub const PORT_STATUS_WARMING_UP: u32 = 11u32;
pub const PORT_TYPE_NET_ATTACHED: u32 = 8u32;
pub const PORT_TYPE_READ: u32 = 2u32;
pub const PORT_TYPE_REDIRECTED: u32 = 4u32;
pub const PORT_TYPE_WRITE: u32 = 1u32;
pub const PPCAPS_BOOKLET_EDGE: u32 = 1u32;
pub const PPCAPS_BORDER_PRINT: u32 = 1u32;
pub const PPCAPS_REVERSE_PAGES_FOR_REVERSE_DUPLEX: u32 = 1u32;
pub const PPCAPS_RIGHT_THEN_DOWN: u32 = 1u32;
pub const PPCAPS_SQUARE_SCALING: u32 = 1u32;
pub const PRINTER_ACCESS_ADMINISTER: u32 = 4u32;
pub const PRINTER_ACCESS_MANAGE_LIMITED: u32 = 64u32;
pub const PRINTER_ACCESS_USE: u32 = 8u32;
pub const PRINTER_ATTRIBUTE_DEFAULT: u32 = 4u32;
pub const PRINTER_ATTRIBUTE_DIRECT: u32 = 2u32;
pub const PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST: u32 = 512u32;
pub const PRINTER_ATTRIBUTE_ENABLE_BIDI: u32 = 2048u32;
pub const PRINTER_ATTRIBUTE_ENABLE_DEVQ: u32 = 128u32;
pub const PRINTER_ATTRIBUTE_ENTERPRISE_CLOUD: u32 = 8388608u32;
pub const PRINTER_ATTRIBUTE_FAX: u32 = 16384u32;
pub const PRINTER_ATTRIBUTE_FRIENDLY_NAME: u32 = 1048576u32;
pub const PRINTER_ATTRIBUTE_HIDDEN: u32 = 32u32;
pub const PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS: u32 = 256u32;
pub const PRINTER_ATTRIBUTE_LOCAL: u32 = 64u32;
pub const PRINTER_ATTRIBUTE_MACHINE: u32 = 524288u32;
pub const PRINTER_ATTRIBUTE_NETWORK: u32 = 16u32;
pub const PRINTER_ATTRIBUTE_PER_USER: u32 = 4194304u32;
pub const PRINTER_ATTRIBUTE_PUBLISHED: u32 = 8192u32;
pub const PRINTER_ATTRIBUTE_PUSHED_MACHINE: u32 = 262144u32;
pub const PRINTER_ATTRIBUTE_PUSHED_USER: u32 = 131072u32;
pub const PRINTER_ATTRIBUTE_QUEUED: u32 = 1u32;
pub const PRINTER_ATTRIBUTE_RAW_ONLY: u32 = 4096u32;
pub const PRINTER_ATTRIBUTE_SHARED: u32 = 8u32;
pub const PRINTER_ATTRIBUTE_TS: u32 = 32768u32;
pub const PRINTER_ATTRIBUTE_TS_GENERIC_DRIVER: u32 = 2097152u32;
pub const PRINTER_ATTRIBUTE_WORK_OFFLINE: u32 = 1024u32;
pub const PRINTER_CHANGE_ADD_FORM: u32 = 65536u32;
pub const PRINTER_CHANGE_ADD_JOB: u32 = 256u32;
pub const PRINTER_CHANGE_ADD_PORT: u32 = 1048576u32;
pub const PRINTER_CHANGE_ADD_PRINTER: u32 = 1u32;
pub const PRINTER_CHANGE_ADD_PRINTER_DRIVER: u32 = 268435456u32;
pub const PRINTER_CHANGE_ADD_PRINT_PROCESSOR: u32 = 16777216u32;
pub const PRINTER_CHANGE_ALL: u32 = 2138570751u32;
pub const PRINTER_CHANGE_CONFIGURE_PORT: u32 = 2097152u32;
pub const PRINTER_CHANGE_DELETE_FORM: u32 = 262144u32;
pub const PRINTER_CHANGE_DELETE_JOB: u32 = 1024u32;
pub const PRINTER_CHANGE_DELETE_PORT: u32 = 4194304u32;
pub const PRINTER_CHANGE_DELETE_PRINTER: u32 = 4u32;
pub const PRINTER_CHANGE_DELETE_PRINTER_DRIVER: u32 = 1073741824u32;
pub const PRINTER_CHANGE_DELETE_PRINT_PROCESSOR: u32 = 67108864u32;
pub const PRINTER_CHANGE_FAILED_CONNECTION_PRINTER: u32 = 8u32;
pub const PRINTER_CHANGE_FORM: u32 = 458752u32;
pub const PRINTER_CHANGE_JOB: u32 = 65280u32;
pub const PRINTER_CHANGE_PORT: u32 = 7340032u32;
pub const PRINTER_CHANGE_PRINTER: u32 = 255u32;
pub const PRINTER_CHANGE_PRINTER_DRIVER: u32 = 1879048192u32;
pub const PRINTER_CHANGE_PRINT_PROCESSOR: u32 = 117440512u32;
pub const PRINTER_CHANGE_SERVER: u32 = 134217728u32;
pub const PRINTER_CHANGE_SET_FORM: u32 = 131072u32;
pub const PRINTER_CHANGE_SET_JOB: u32 = 512u32;
pub const PRINTER_CHANGE_SET_PRINTER: u32 = 2u32;
pub const PRINTER_CHANGE_SET_PRINTER_DRIVER: u32 = 536870912u32;
pub const PRINTER_CHANGE_TIMEOUT: u32 = 2147483648u32;
pub const PRINTER_CHANGE_WRITE_JOB: u32 = 2048u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTER_CONNECTION_INFO_1A {
pub dwFlags: u32,
pub pszDriverName: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTER_CONNECTION_INFO_1A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTER_CONNECTION_INFO_1A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTER_CONNECTION_INFO_1W {
pub dwFlags: u32,
pub pszDriverName: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTER_CONNECTION_INFO_1W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTER_CONNECTION_INFO_1W {
fn clone(&self) -> Self {
*self
}
}
pub const PRINTER_CONNECTION_MISMATCH: u32 = 32u32;
pub const PRINTER_CONNECTION_NO_UI: u32 = 64u32;
pub const PRINTER_CONTROL_PAUSE: u32 = 1u32;
pub const PRINTER_CONTROL_PURGE: u32 = 3u32;
pub const PRINTER_CONTROL_RESUME: u32 = 2u32;
pub const PRINTER_CONTROL_SET_STATUS: u32 = 4u32;
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub struct PRINTER_DEFAULTSA {
pub pDatatype: super::super::Foundation::PSTR,
pub pDevMode: *mut super::Gdi::DEVMODEA,
pub DesiredAccess: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::marker::Copy for PRINTER_DEFAULTSA {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for PRINTER_DEFAULTSA {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub struct PRINTER_DEFAULTSW {
pub pDatatype: super::super::Foundation::PWSTR,
pub pDevMode: *mut super::Gdi::DEVMODEW,
pub DesiredAccess: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::marker::Copy for PRINTER_DEFAULTSW {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for PRINTER_DEFAULTSW {
fn clone(&self) -> Self {
*self
}
}
pub const PRINTER_DRIVER_CATEGORY_3D: u32 = 4096u32;
pub const PRINTER_DRIVER_CATEGORY_CLOUD: u32 = 8192u32;
pub const PRINTER_DRIVER_CATEGORY_FAX: u32 = 64u32;
pub const PRINTER_DRIVER_CATEGORY_FILE: u32 = 128u32;
pub const PRINTER_DRIVER_CATEGORY_SERVICE: u32 = 512u32;
pub const PRINTER_DRIVER_CATEGORY_VIRTUAL: u32 = 256u32;
pub const PRINTER_DRIVER_CLASS: u32 = 8u32;
pub const PRINTER_DRIVER_DERIVED: u32 = 16u32;
pub const PRINTER_DRIVER_NOT_SHAREABLE: u32 = 32u32;
pub const PRINTER_DRIVER_PACKAGE_AWARE: u32 = 1u32;
pub const PRINTER_DRIVER_SANDBOX_DISABLED: u32 = 2048u32;
pub const PRINTER_DRIVER_SANDBOX_ENABLED: u32 = 4u32;
pub const PRINTER_DRIVER_SOFT_RESET_REQUIRED: u32 = 1024u32;
pub const PRINTER_DRIVER_XPS: u32 = 2u32;
pub const PRINTER_ENUM_CATEGORY_3D: u32 = 67108864u32;
pub const PRINTER_ENUM_CATEGORY_ALL: u32 = 33554432u32;
pub const PRINTER_ENUM_CONNECTIONS: u32 = 4u32;
pub const PRINTER_ENUM_CONTAINER: u32 = 32768u32;
pub const PRINTER_ENUM_DEFAULT: u32 = 1u32;
pub const PRINTER_ENUM_EXPAND: u32 = 16384u32;
pub const PRINTER_ENUM_FAVORITE: u32 = 4u32;
pub const PRINTER_ENUM_HIDE: u32 = 16777216u32;
pub const PRINTER_ENUM_ICON1: u32 = 65536u32;
pub const PRINTER_ENUM_ICON2: u32 = 131072u32;
pub const PRINTER_ENUM_ICON3: u32 = 262144u32;
pub const PRINTER_ENUM_ICON4: u32 = 524288u32;
pub const PRINTER_ENUM_ICON5: u32 = 1048576u32;
pub const PRINTER_ENUM_ICON6: u32 = 2097152u32;
pub const PRINTER_ENUM_ICON7: u32 = 4194304u32;
pub const PRINTER_ENUM_ICON8: u32 = 8388608u32;
pub const PRINTER_ENUM_ICONMASK: u32 = 16711680u32;
pub const PRINTER_ENUM_LOCAL: u32 = 2u32;
pub const PRINTER_ENUM_NAME: u32 = 8u32;
pub const PRINTER_ENUM_NETWORK: u32 = 64u32;
pub const PRINTER_ENUM_REMOTE: u32 = 16u32;
pub const PRINTER_ENUM_SHARED: u32 = 32u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTER_ENUM_VALUESA {
pub pValueName: super::super::Foundation::PSTR,
pub cbValueName: u32,
pub dwType: u32,
pub pData: *mut u8,
pub cbData: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTER_ENUM_VALUESA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTER_ENUM_VALUESA {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTER_ENUM_VALUESW {
pub pValueName: super::super::Foundation::PWSTR,
pub cbValueName: u32,
pub dwType: u32,
pub pData: *mut u8,
pub cbData: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTER_ENUM_VALUESW {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTER_ENUM_VALUESW {
fn clone(&self) -> Self {
*self
}
}
pub const PRINTER_ERROR_INFORMATION: u32 = 2147483648u32;
pub const PRINTER_ERROR_JAM: u32 = 2u32;
pub const PRINTER_ERROR_OUTOFPAPER: u32 = 1u32;
pub const PRINTER_ERROR_OUTOFTONER: u32 = 4u32;
pub const PRINTER_ERROR_SEVERE: u32 = 536870912u32;
pub const PRINTER_ERROR_WARNING: u32 = 1073741824u32;
pub const PRINTER_EVENT_ADD_CONNECTION: u32 = 1u32;
pub const PRINTER_EVENT_ADD_CONNECTION_NO_UI: u32 = 9u32;
pub const PRINTER_EVENT_ATTRIBUTES_CHANGED: u32 = 7u32;
#[repr(C)]
pub struct PRINTER_EVENT_ATTRIBUTES_INFO {
pub cbSize: u32,
pub dwOldAttributes: u32,
pub dwNewAttributes: u32,
}
impl ::core::marker::Copy for PRINTER_EVENT_ATTRIBUTES_INFO {}
impl ::core::clone::Clone for PRINTER_EVENT_ATTRIBUTES_INFO {
fn clone(&self) -> Self {
*self
}
}
pub const PRINTER_EVENT_CACHE_DELETE: u32 = 6u32;
pub const PRINTER_EVENT_CACHE_REFRESH: u32 = 5u32;
pub const PRINTER_EVENT_CONFIGURATION_CHANGE: u32 = 0u32;
pub const PRINTER_EVENT_CONFIGURATION_UPDATE: u32 = 8u32;
pub const PRINTER_EVENT_DELETE: u32 = 4u32;
pub const PRINTER_EVENT_DELETE_CONNECTION: u32 = 2u32;
pub const PRINTER_EVENT_DELETE_CONNECTION_NO_UI: u32 = 10u32;
pub const PRINTER_EVENT_FLAG_NO_UI: u32 = 1u32;
pub const PRINTER_EVENT_INITIALIZE: u32 = 3u32;
pub const PRINTER_EXTENSION_DETAILEDREASON_PRINTER_STATUS: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
data1: 1566185220,
data2: 57297,
data3: 16769,
data4: [142, 238, 129, 92, 134, 237, 173, 49],
};
pub const PRINTER_EXTENSION_REASON_DRIVER_EVENT: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
data1: 599462696,
data2: 25566,
data3: 17043,
data4: [145, 91, 166, 162, 61, 146, 154, 203],
};
pub const PRINTER_EXTENSION_REASON_PRINT_PREFERENCES: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 3968804383, data2: 9852, data3: 18079, data4: [181, 214, 57, 51, 2, 60, 41, 204] };
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTER_INFO_1A {
pub Flags: u32,
pub pDescription: super::super::Foundation::PSTR,
pub pName: super::super::Foundation::PSTR,
pub pComment: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTER_INFO_1A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTER_INFO_1A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTER_INFO_1W {
pub Flags: u32,
pub pDescription: super::super::Foundation::PWSTR,
pub pName: super::super::Foundation::PWSTR,
pub pComment: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTER_INFO_1W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTER_INFO_1W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
pub struct PRINTER_INFO_2A {
pub pServerName: super::super::Foundation::PSTR,
pub pPrinterName: super::super::Foundation::PSTR,
pub pShareName: super::super::Foundation::PSTR,
pub pPortName: super::super::Foundation::PSTR,
pub pDriverName: super::super::Foundation::PSTR,
pub pComment: super::super::Foundation::PSTR,
pub pLocation: super::super::Foundation::PSTR,
pub pDevMode: *mut super::Gdi::DEVMODEA,
pub pSepFile: super::super::Foundation::PSTR,
pub pPrintProcessor: super::super::Foundation::PSTR,
pub pDatatype: super::super::Foundation::PSTR,
pub pParameters: super::super::Foundation::PSTR,
pub pSecurityDescriptor: *mut super::super::Security::SECURITY_DESCRIPTOR,
pub Attributes: u32,
pub Priority: u32,
pub DefaultPriority: u32,
pub StartTime: u32,
pub UntilTime: u32,
pub Status: u32,
pub cJobs: u32,
pub AveragePPM: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
impl ::core::marker::Copy for PRINTER_INFO_2A {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
impl ::core::clone::Clone for PRINTER_INFO_2A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
pub struct PRINTER_INFO_2W {
pub pServerName: super::super::Foundation::PWSTR,
pub pPrinterName: super::super::Foundation::PWSTR,
pub pShareName: super::super::Foundation::PWSTR,
pub pPortName: super::super::Foundation::PWSTR,
pub pDriverName: super::super::Foundation::PWSTR,
pub pComment: super::super::Foundation::PWSTR,
pub pLocation: super::super::Foundation::PWSTR,
pub pDevMode: *mut super::Gdi::DEVMODEW,
pub pSepFile: super::super::Foundation::PWSTR,
pub pPrintProcessor: super::super::Foundation::PWSTR,
pub pDatatype: super::super::Foundation::PWSTR,
pub pParameters: super::super::Foundation::PWSTR,
pub pSecurityDescriptor: *mut super::super::Security::SECURITY_DESCRIPTOR,
pub Attributes: u32,
pub Priority: u32,
pub DefaultPriority: u32,
pub StartTime: u32,
pub UntilTime: u32,
pub Status: u32,
pub cJobs: u32,
pub AveragePPM: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
impl ::core::marker::Copy for PRINTER_INFO_2W {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi", feature = "Win32_Security"))]
impl ::core::clone::Clone for PRINTER_INFO_2W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security"))]
pub struct PRINTER_INFO_3 {
pub pSecurityDescriptor: *mut super::super::Security::SECURITY_DESCRIPTOR,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security"))]
impl ::core::marker::Copy for PRINTER_INFO_3 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security"))]
impl ::core::clone::Clone for PRINTER_INFO_3 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTER_INFO_4A {
pub pPrinterName: super::super::Foundation::PSTR,
pub pServerName: super::super::Foundation::PSTR,
pub Attributes: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTER_INFO_4A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTER_INFO_4A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTER_INFO_4W {
pub pPrinterName: super::super::Foundation::PWSTR,
pub pServerName: super::super::Foundation::PWSTR,
pub Attributes: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTER_INFO_4W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTER_INFO_4W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTER_INFO_5A {
pub pPrinterName: super::super::Foundation::PSTR,
pub pPortName: super::super::Foundation::PSTR,
pub Attributes: u32,
pub DeviceNotSelectedTimeout: u32,
pub TransmissionRetryTimeout: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTER_INFO_5A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTER_INFO_5A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTER_INFO_5W {
pub pPrinterName: super::super::Foundation::PWSTR,
pub pPortName: super::super::Foundation::PWSTR,
pub Attributes: u32,
pub DeviceNotSelectedTimeout: u32,
pub TransmissionRetryTimeout: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTER_INFO_5W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTER_INFO_5W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct PRINTER_INFO_6 {
pub dwStatus: u32,
}
impl ::core::marker::Copy for PRINTER_INFO_6 {}
impl ::core::clone::Clone for PRINTER_INFO_6 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTER_INFO_7A {
pub pszObjectGUID: super::super::Foundation::PSTR,
pub dwAction: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTER_INFO_7A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTER_INFO_7A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTER_INFO_7W {
pub pszObjectGUID: super::super::Foundation::PWSTR,
pub dwAction: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTER_INFO_7W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTER_INFO_7W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub struct PRINTER_INFO_8A {
pub pDevMode: *mut super::Gdi::DEVMODEA,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::marker::Copy for PRINTER_INFO_8A {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for PRINTER_INFO_8A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub struct PRINTER_INFO_8W {
pub pDevMode: *mut super::Gdi::DEVMODEW,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::marker::Copy for PRINTER_INFO_8W {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for PRINTER_INFO_8W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub struct PRINTER_INFO_9A {
pub pDevMode: *mut super::Gdi::DEVMODEA,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::marker::Copy for PRINTER_INFO_9A {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for PRINTER_INFO_9A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub struct PRINTER_INFO_9W {
pub pDevMode: *mut super::Gdi::DEVMODEW,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::marker::Copy for PRINTER_INFO_9W {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for PRINTER_INFO_9W {
fn clone(&self) -> Self {
*self
}
}
pub const PRINTER_NOTIFY_CATEGORY_3D: u32 = 8192u32;
pub const PRINTER_NOTIFY_CATEGORY_ALL: u32 = 4096u32;
pub const PRINTER_NOTIFY_FIELD_ATTRIBUTES: u32 = 13u32;
pub const PRINTER_NOTIFY_FIELD_AVERAGE_PPM: u32 = 21u32;
pub const PRINTER_NOTIFY_FIELD_BRANCH_OFFICE_PRINTING: u32 = 28u32;
pub const PRINTER_NOTIFY_FIELD_BYTES_PRINTED: u32 = 25u32;
pub const PRINTER_NOTIFY_FIELD_CJOBS: u32 = 20u32;
pub const PRINTER_NOTIFY_FIELD_COMMENT: u32 = 5u32;
pub const PRINTER_NOTIFY_FIELD_DATATYPE: u32 = 11u32;
pub const PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: u32 = 15u32;
pub const PRINTER_NOTIFY_FIELD_DEVMODE: u32 = 7u32;
pub const PRINTER_NOTIFY_FIELD_DRIVER_NAME: u32 = 4u32;
pub const PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: u32 = 27u32;
pub const PRINTER_NOTIFY_FIELD_LOCATION: u32 = 6u32;
pub const PRINTER_NOTIFY_FIELD_OBJECT_GUID: u32 = 26u32;
pub const PRINTER_NOTIFY_FIELD_PAGES_PRINTED: u32 = 23u32;
pub const PRINTER_NOTIFY_FIELD_PARAMETERS: u32 = 10u32;
pub const PRINTER_NOTIFY_FIELD_PORT_NAME: u32 = 3u32;
pub const PRINTER_NOTIFY_FIELD_PRINTER_NAME: u32 = 1u32;
pub const PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: u32 = 9u32;
pub const PRINTER_NOTIFY_FIELD_PRIORITY: u32 = 14u32;
pub const PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: u32 = 12u32;
pub const PRINTER_NOTIFY_FIELD_SEPFILE: u32 = 8u32;
pub const PRINTER_NOTIFY_FIELD_SERVER_NAME: u32 = 0u32;
pub const PRINTER_NOTIFY_FIELD_SHARE_NAME: u32 = 2u32;
pub const PRINTER_NOTIFY_FIELD_START_TIME: u32 = 16u32;
pub const PRINTER_NOTIFY_FIELD_STATUS: u32 = 18u32;
pub const PRINTER_NOTIFY_FIELD_STATUS_STRING: u32 = 19u32;
pub const PRINTER_NOTIFY_FIELD_TOTAL_BYTES: u32 = 24u32;
pub const PRINTER_NOTIFY_FIELD_TOTAL_PAGES: u32 = 22u32;
pub const PRINTER_NOTIFY_FIELD_UNTIL_TIME: u32 = 17u32;
#[repr(C)]
pub struct PRINTER_NOTIFY_INFO {
pub Version: u32,
pub Flags: u32,
pub Count: u32,
pub aData: [PRINTER_NOTIFY_INFO_DATA; 1],
}
impl ::core::marker::Copy for PRINTER_NOTIFY_INFO {}
impl ::core::clone::Clone for PRINTER_NOTIFY_INFO {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct PRINTER_NOTIFY_INFO_DATA {
pub Type: u16,
pub Field: u16,
pub Reserved: u32,
pub Id: u32,
pub NotifyData: PRINTER_NOTIFY_INFO_DATA_0,
}
impl ::core::marker::Copy for PRINTER_NOTIFY_INFO_DATA {}
impl ::core::clone::Clone for PRINTER_NOTIFY_INFO_DATA {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub union PRINTER_NOTIFY_INFO_DATA_0 {
pub adwData: [u32; 2],
pub Data: PRINTER_NOTIFY_INFO_DATA_0_0,
}
impl ::core::marker::Copy for PRINTER_NOTIFY_INFO_DATA_0 {}
impl ::core::clone::Clone for PRINTER_NOTIFY_INFO_DATA_0 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct PRINTER_NOTIFY_INFO_DATA_0_0 {
pub cbBuf: u32,
pub pBuf: *mut ::core::ffi::c_void,
}
impl ::core::marker::Copy for PRINTER_NOTIFY_INFO_DATA_0_0 {}
impl ::core::clone::Clone for PRINTER_NOTIFY_INFO_DATA_0_0 {
fn clone(&self) -> Self {
*self
}
}
pub const PRINTER_NOTIFY_INFO_DATA_COMPACT: u32 = 1u32;
pub const PRINTER_NOTIFY_INFO_DISCARDED: u32 = 1u32;
#[repr(C)]
pub struct PRINTER_NOTIFY_INIT {
pub Size: u32,
pub Reserved: u32,
pub PollTime: u32,
}
impl ::core::marker::Copy for PRINTER_NOTIFY_INIT {}
impl ::core::clone::Clone for PRINTER_NOTIFY_INIT {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct PRINTER_NOTIFY_OPTIONS {
pub Version: u32,
pub Flags: u32,
pub Count: u32,
pub pTypes: *mut PRINTER_NOTIFY_OPTIONS_TYPE,
}
impl ::core::marker::Copy for PRINTER_NOTIFY_OPTIONS {}
impl ::core::clone::Clone for PRINTER_NOTIFY_OPTIONS {
fn clone(&self) -> Self {
*self
}
}
pub const PRINTER_NOTIFY_OPTIONS_REFRESH: u32 = 1u32;
#[repr(C)]
pub struct PRINTER_NOTIFY_OPTIONS_TYPE {
pub Type: u16,
pub Reserved0: u16,
pub Reserved1: u32,
pub Reserved2: u32,
pub Count: u32,
pub pFields: *mut u16,
}
impl ::core::marker::Copy for PRINTER_NOTIFY_OPTIONS_TYPE {}
impl ::core::clone::Clone for PRINTER_NOTIFY_OPTIONS_TYPE {
fn clone(&self) -> Self {
*self
}
}
pub const PRINTER_NOTIFY_STATUS_ENDPOINT: u32 = 1u32;
pub const PRINTER_NOTIFY_STATUS_INFO: u32 = 4u32;
pub const PRINTER_NOTIFY_STATUS_POLL: u32 = 2u32;
pub const PRINTER_NOTIFY_TYPE: u32 = 0u32;
pub const PRINTER_OEMINTF_VERSION: u32 = 65536u32;
#[repr(C)]
pub struct PRINTER_OPTIONSA {
pub cbSize: u32,
pub dwFlags: u32,
}
impl ::core::marker::Copy for PRINTER_OPTIONSA {}
impl ::core::clone::Clone for PRINTER_OPTIONSA {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct PRINTER_OPTIONSW {
pub cbSize: u32,
pub dwFlags: u32,
}
impl ::core::marker::Copy for PRINTER_OPTIONSW {}
impl ::core::clone::Clone for PRINTER_OPTIONSW {
fn clone(&self) -> Self {
*self
}
}
pub type PRINTER_OPTION_FLAGS = i32;
pub const PRINTER_OPTION_NO_CACHE: PRINTER_OPTION_FLAGS = 1i32;
pub const PRINTER_OPTION_CACHE: PRINTER_OPTION_FLAGS = 2i32;
pub const PRINTER_OPTION_CLIENT_CHANGE: PRINTER_OPTION_FLAGS = 4i32;
pub const PRINTER_OPTION_NO_CLIENT_DATA: PRINTER_OPTION_FLAGS = 8i32;
pub const PRINTER_STATUS_BUSY: u32 = 512u32;
pub const PRINTER_STATUS_DOOR_OPEN: u32 = 4194304u32;
pub const PRINTER_STATUS_DRIVER_UPDATE_NEEDED: u32 = 67108864u32;
pub const PRINTER_STATUS_ERROR: u32 = 2u32;
pub const PRINTER_STATUS_INITIALIZING: u32 = 32768u32;
pub const PRINTER_STATUS_IO_ACTIVE: u32 = 256u32;
pub const PRINTER_STATUS_MANUAL_FEED: u32 = 32u32;
pub const PRINTER_STATUS_NOT_AVAILABLE: u32 = 4096u32;
pub const PRINTER_STATUS_NO_TONER: u32 = 262144u32;
pub const PRINTER_STATUS_OFFLINE: u32 = 128u32;
pub const PRINTER_STATUS_OUTPUT_BIN_FULL: u32 = 2048u32;
pub const PRINTER_STATUS_OUT_OF_MEMORY: u32 = 2097152u32;
pub const PRINTER_STATUS_PAGE_PUNT: u32 = 524288u32;
pub const PRINTER_STATUS_PAPER_JAM: u32 = 8u32;
pub const PRINTER_STATUS_PAPER_OUT: u32 = 16u32;
pub const PRINTER_STATUS_PAPER_PROBLEM: u32 = 64u32;
pub const PRINTER_STATUS_PAUSED: u32 = 1u32;
pub const PRINTER_STATUS_PENDING_DELETION: u32 = 4u32;
pub const PRINTER_STATUS_POWER_SAVE: u32 = 16777216u32;
pub const PRINTER_STATUS_PRINTING: u32 = 1024u32;
pub const PRINTER_STATUS_PROCESSING: u32 = 16384u32;
pub const PRINTER_STATUS_SERVER_OFFLINE: u32 = 33554432u32;
pub const PRINTER_STATUS_SERVER_UNKNOWN: u32 = 8388608u32;
pub const PRINTER_STATUS_TONER_LOW: u32 = 131072u32;
pub const PRINTER_STATUS_USER_INTERVENTION: u32 = 1048576u32;
pub const PRINTER_STATUS_WAITING: u32 = 8192u32;
pub const PRINTER_STATUS_WARMING_UP: u32 = 65536u32;
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub struct PRINTIFI32 {
pub cjThis: u32,
pub cjIfiExtra: u32,
pub dpwszFamilyName: i32,
pub dpwszStyleName: i32,
pub dpwszFaceName: i32,
pub dpwszUniqueName: i32,
pub dpFontSim: i32,
pub lEmbedId: i32,
pub lItalicAngle: i32,
pub lCharBias: i32,
pub dpCharSets: i32,
pub jWinCharSet: u8,
pub jWinPitchAndFamily: u8,
pub usWinWeight: u16,
pub flInfo: u32,
pub fsSelection: u16,
pub fsType: u16,
pub fwdUnitsPerEm: i16,
pub fwdLowestPPEm: i16,
pub fwdWinAscender: i16,
pub fwdWinDescender: i16,
pub fwdMacAscender: i16,
pub fwdMacDescender: i16,
pub fwdMacLineGap: i16,
pub fwdTypoAscender: i16,
pub fwdTypoDescender: i16,
pub fwdTypoLineGap: i16,
pub fwdAveCharWidth: i16,
pub fwdMaxCharInc: i16,
pub fwdCapHeight: i16,
pub fwdXHeight: i16,
pub fwdSubscriptXSize: i16,
pub fwdSubscriptYSize: i16,
pub fwdSubscriptXOffset: i16,
pub fwdSubscriptYOffset: i16,
pub fwdSuperscriptXSize: i16,
pub fwdSuperscriptYSize: i16,
pub fwdSuperscriptXOffset: i16,
pub fwdSuperscriptYOffset: i16,
pub fwdUnderscoreSize: i16,
pub fwdUnderscorePosition: i16,
pub fwdStrikeoutSize: i16,
pub fwdStrikeoutPosition: i16,
pub chFirstChar: u8,
pub chLastChar: u8,
pub chDefaultChar: u8,
pub chBreakChar: u8,
pub wcFirstChar: u16,
pub wcLastChar: u16,
pub wcDefaultChar: u16,
pub wcBreakChar: u16,
pub ptlBaseline: super::super::Foundation::POINTL,
pub ptlAspect: super::super::Foundation::POINTL,
pub ptlCaret: super::super::Foundation::POINTL,
pub rclFontBox: super::super::Foundation::RECTL,
pub achVendId: [u8; 4],
pub cKerningPairs: u32,
pub ulPanoseCulture: u32,
pub panose: super::Gdi::PANOSE,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::marker::Copy for PRINTIFI32 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for PRINTIFI32 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
pub struct PRINTPROCESSOROPENDATA {
pub pDevMode: *mut super::Gdi::DEVMODEA,
pub pDatatype: super::super::Foundation::PWSTR,
pub pParameters: super::super::Foundation::PWSTR,
pub pDocumentName: super::super::Foundation::PWSTR,
pub JobId: u32,
pub pOutputFile: super::super::Foundation::PWSTR,
pub pPrinterName: super::super::Foundation::PWSTR,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::marker::Copy for PRINTPROCESSOROPENDATA {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
impl ::core::clone::Clone for PRINTPROCESSOROPENDATA {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct PRINTPROCESSOR_CAPS_1 {
pub dwLevel: u32,
pub dwNupOptions: u32,
pub dwPageOrderFlags: u32,
pub dwNumberOfCopies: u32,
}
impl ::core::marker::Copy for PRINTPROCESSOR_CAPS_1 {}
impl ::core::clone::Clone for PRINTPROCESSOR_CAPS_1 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct PRINTPROCESSOR_CAPS_2 {
pub dwLevel: u32,
pub dwNupOptions: u32,
pub dwPageOrderFlags: u32,
pub dwNumberOfCopies: u32,
pub dwDuplexHandlingCaps: u32,
pub dwNupDirectionCaps: u32,
pub dwNupBorderCaps: u32,
pub dwBookletHandlingCaps: u32,
pub dwScalingCaps: u32,
}
impl ::core::marker::Copy for PRINTPROCESSOR_CAPS_2 {}
impl ::core::clone::Clone for PRINTPROCESSOR_CAPS_2 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTPROCESSOR_INFO_1A {
pub pName: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTPROCESSOR_INFO_1A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTPROCESSOR_INFO_1A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINTPROCESSOR_INFO_1W {
pub pName: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINTPROCESSOR_INFO_1W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINTPROCESSOR_INFO_1W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct PRINTPROVIDOR {
pub fpOpenPrinter: isize,
pub fpSetJob: isize,
pub fpGetJob: isize,
pub fpEnumJobs: isize,
pub fpAddPrinter: isize,
pub fpDeletePrinter: isize,
pub fpSetPrinter: isize,
pub fpGetPrinter: isize,
pub fpEnumPrinters: isize,
pub fpAddPrinterDriver: isize,
pub fpEnumPrinterDrivers: isize,
pub fpGetPrinterDriver: isize,
pub fpGetPrinterDriverDirectory: isize,
pub fpDeletePrinterDriver: isize,
pub fpAddPrintProcessor: isize,
pub fpEnumPrintProcessors: isize,
pub fpGetPrintProcessorDirectory: isize,
pub fpDeletePrintProcessor: isize,
pub fpEnumPrintProcessorDatatypes: isize,
pub fpStartDocPrinter: isize,
pub fpStartPagePrinter: isize,
pub fpWritePrinter: isize,
pub fpEndPagePrinter: isize,
pub fpAbortPrinter: isize,
pub fpReadPrinter: isize,
pub fpEndDocPrinter: isize,
pub fpAddJob: isize,
pub fpScheduleJob: isize,
pub fpGetPrinterData: isize,
pub fpSetPrinterData: isize,
pub fpWaitForPrinterChange: isize,
pub fpClosePrinter: isize,
pub fpAddForm: isize,
pub fpDeleteForm: isize,
pub fpGetForm: isize,
pub fpSetForm: isize,
pub fpEnumForms: isize,
pub fpEnumMonitors: isize,
pub fpEnumPorts: isize,
pub fpAddPort: isize,
pub fpConfigurePort: isize,
pub fpDeletePort: isize,
pub fpCreatePrinterIC: isize,
pub fpPlayGdiScriptOnPrinterIC: isize,
pub fpDeletePrinterIC: isize,
pub fpAddPrinterConnection: isize,
pub fpDeletePrinterConnection: isize,
pub fpPrinterMessageBox: isize,
pub fpAddMonitor: isize,
pub fpDeleteMonitor: isize,
pub fpResetPrinter: isize,
pub fpGetPrinterDriverEx: isize,
pub fpFindFirstPrinterChangeNotification: isize,
pub fpFindClosePrinterChangeNotification: isize,
pub fpAddPortEx: isize,
pub fpShutDown: isize,
pub fpRefreshPrinterChangeNotification: isize,
pub fpOpenPrinterEx: isize,
pub fpAddPrinterEx: isize,
pub fpSetPort: isize,
pub fpEnumPrinterData: isize,
pub fpDeletePrinterData: isize,
pub fpClusterSplOpen: isize,
pub fpClusterSplClose: isize,
pub fpClusterSplIsAlive: isize,
pub fpSetPrinterDataEx: isize,
pub fpGetPrinterDataEx: isize,
pub fpEnumPrinterDataEx: isize,
pub fpEnumPrinterKey: isize,
pub fpDeletePrinterDataEx: isize,
pub fpDeletePrinterKey: isize,
pub fpSeekPrinter: isize,
pub fpDeletePrinterDriverEx: isize,
pub fpAddPerMachineConnection: isize,
pub fpDeletePerMachineConnection: isize,
pub fpEnumPerMachineConnections: isize,
pub fpXcvData: isize,
pub fpAddPrinterDriverEx: isize,
pub fpSplReadPrinter: isize,
pub fpDriverUnloadComplete: isize,
pub fpGetSpoolFileInfo: isize,
pub fpCommitSpoolData: isize,
pub fpCloseSpoolFileHandle: isize,
pub fpFlushPrinter: isize,
pub fpSendRecvBidiData: isize,
pub fpAddPrinterConnection2: isize,
pub fpGetPrintClassObject: isize,
pub fpReportJobProcessingProgress: isize,
pub fpEnumAndLogProvidorObjects: isize,
pub fpInternalGetPrinterDriver: isize,
pub fpFindCompatibleDriver: isize,
pub fpGetJobNamedPropertyValue: isize,
pub fpSetJobNamedProperty: isize,
pub fpDeleteJobNamedProperty: isize,
pub fpEnumJobNamedProperties: isize,
pub fpPowerEvent: isize,
pub fpGetUserPropertyBag: isize,
pub fpCanShutdown: isize,
pub fpLogJobInfoForBranchOffice: isize,
pub fpRegeneratePrintDeviceCapabilities: isize,
pub fpPrintSupportOperation: isize,
pub fpIppCreateJobOnPrinter: isize,
pub fpIppGetJobAttributes: isize,
pub fpIppSetJobAttributes: isize,
pub fpIppGetPrinterAttributes: isize,
pub fpIppSetPrinterAttributes: isize,
}
impl ::core::marker::Copy for PRINTPROVIDOR {}
impl ::core::clone::Clone for PRINTPROVIDOR {
fn clone(&self) -> Self {
*self
}
}
pub const PRINT_APP_BIDI_NOTIFY_CHANNEL: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
data1: 716886563,
data2: 47508,
data3: 19146,
data4: [130, 252, 69, 113, 177, 181, 133, 172],
};
pub type PRINT_EXECUTION_CONTEXT = i32;
pub const PRINT_EXECUTION_CONTEXT_APPLICATION: PRINT_EXECUTION_CONTEXT = 0i32;
pub const PRINT_EXECUTION_CONTEXT_SPOOLER_SERVICE: PRINT_EXECUTION_CONTEXT = 1i32;
pub const PRINT_EXECUTION_CONTEXT_SPOOLER_ISOLATION_HOST: PRINT_EXECUTION_CONTEXT = 2i32;
pub const PRINT_EXECUTION_CONTEXT_FILTER_PIPELINE: PRINT_EXECUTION_CONTEXT = 3i32;
pub const PRINT_EXECUTION_CONTEXT_WOW64: PRINT_EXECUTION_CONTEXT = 4i32;
#[repr(C)]
pub struct PRINT_EXECUTION_DATA {
pub context: PRINT_EXECUTION_CONTEXT,
pub clientAppPID: u32,
}
impl ::core::marker::Copy for PRINT_EXECUTION_DATA {}
impl ::core::clone::Clone for PRINT_EXECUTION_DATA {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PRINT_FEATURE_OPTION {
pub pszFeature: super::super::Foundation::PSTR,
pub pszOption: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PRINT_FEATURE_OPTION {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PRINT_FEATURE_OPTION {
fn clone(&self) -> Self {
*self
}
}
pub const PRINT_PORT_MONITOR_NOTIFY_CHANNEL: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
data1: 635386638,
data2: 29865,
data3: 18421,
data4: [128, 206, 121, 180, 177, 235, 92, 88],
};
#[repr(C)]
#[cfg(feature = "Win32_UI_WindowsAndMessaging")]
pub struct PROPSHEETUI_GETICON_INFO {
pub cbSize: u16,
pub Flags: u16,
pub cxIcon: u16,
pub cyIcon: u16,
pub hIcon: super::super::UI::WindowsAndMessaging::HICON,
}
#[cfg(feature = "Win32_UI_WindowsAndMessaging")]
impl ::core::marker::Copy for PROPSHEETUI_GETICON_INFO {}
#[cfg(feature = "Win32_UI_WindowsAndMessaging")]
impl ::core::clone::Clone for PROPSHEETUI_GETICON_INFO {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PROPSHEETUI_INFO {
pub cbSize: u16,
pub Version: u16,
pub Flags: u16,
pub Reason: u16,
pub hComPropSheet: super::super::Foundation::HANDLE,
pub pfnComPropSheet: PFNCOMPROPSHEET,
pub lParamInit: super::super::Foundation::LPARAM,
pub UserData: usize,
pub Result: usize,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PROPSHEETUI_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PROPSHEETUI_INFO {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub struct PROPSHEETUI_INFO_HEADER {
pub cbSize: u16,
pub Flags: u16,
pub pTitle: *mut i8,
pub hWndParent: super::super::Foundation::HWND,
pub hInst: super::super::Foundation::HINSTANCE,
pub Anonymous: PROPSHEETUI_INFO_HEADER_0,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for PROPSHEETUI_INFO_HEADER {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for PROPSHEETUI_INFO_HEADER {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub union PROPSHEETUI_INFO_HEADER_0 {
pub hIcon: super::super::UI::WindowsAndMessaging::HICON,
pub IconID: usize,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::marker::Copy for PROPSHEETUI_INFO_HEADER_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
impl ::core::clone::Clone for PROPSHEETUI_INFO_HEADER_0 {
fn clone(&self) -> Self {
*self
}
}
pub const PROPSHEETUI_INFO_VERSION: u32 = 256u32;
pub const PROPSHEETUI_REASON_BEFORE_INIT: u32 = 5u32;
pub const PROPSHEETUI_REASON_DESTROY: u32 = 2u32;
pub const PROPSHEETUI_REASON_GET_ICON: u32 = 4u32;
pub const PROPSHEETUI_REASON_GET_INFO_HEADER: u32 = 1u32;
pub const PROPSHEETUI_REASON_INIT: u32 = 0u32;
pub const PROPSHEETUI_REASON_SET_RESULT: u32 = 3u32;
pub const PROTOCOL_LPR_TYPE: u32 = 2u32;
pub const PROTOCOL_RAWTCP_TYPE: u32 = 1u32;
pub const PROTOCOL_UNKNOWN_TYPE: u32 = 0u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PROVIDOR_INFO_1A {
pub pName: super::super::Foundation::PSTR,
pub pEnvironment: super::super::Foundation::PSTR,
pub pDLLName: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PROVIDOR_INFO_1A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PROVIDOR_INFO_1A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PROVIDOR_INFO_1W {
pub pName: super::super::Foundation::PWSTR,
pub pEnvironment: super::super::Foundation::PWSTR,
pub pDLLName: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PROVIDOR_INFO_1W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PROVIDOR_INFO_1W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PROVIDOR_INFO_2A {
pub pOrder: super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PROVIDOR_INFO_2A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PROVIDOR_INFO_2A {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PROVIDOR_INFO_2W {
pub pOrder: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PROVIDOR_INFO_2W {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PROVIDOR_INFO_2W {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct PSCRIPT5_PRIVATE_DEVMODE {
pub wReserved: [u16; 57],
pub wSize: u16,
}
impl ::core::marker::Copy for PSCRIPT5_PRIVATE_DEVMODE {}
impl ::core::clone::Clone for PSCRIPT5_PRIVATE_DEVMODE {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PSPINFO {
pub cbSize: u16,
pub wReserved: u16,
pub hComPropSheet: super::super::Foundation::HANDLE,
pub hCPSUIPage: super::super::Foundation::HANDLE,
pub pfnComPropSheet: PFNCOMPROPSHEET,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PSPINFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PSPINFO {
fn clone(&self) -> Self {
*self
}
}
pub const PSUIHDRF_DEFTITLE: u32 = 16u32;
pub const PSUIHDRF_EXACT_PTITLE: u32 = 32u32;
pub const PSUIHDRF_NOAPPLYNOW: u32 = 2u32;
pub const PSUIHDRF_OBSOLETE: u32 = 1u32;
pub const PSUIHDRF_PROPTITLE: u32 = 4u32;
pub const PSUIHDRF_USEHICON: u32 = 8u32;
pub const PSUIINFO_UNICODE: u32 = 1u32;
pub const PSUIPAGEINSERT_DLL: u32 = 5u32;
pub const PSUIPAGEINSERT_GROUP_PARENT: u32 = 0u32;
pub const PSUIPAGEINSERT_HPROPSHEETPAGE: u32 = 4u32;
pub const PSUIPAGEINSERT_PCOMPROPSHEETUI: u32 = 1u32;
pub const PSUIPAGEINSERT_PFNPROPSHEETUI: u32 = 2u32;
pub const PSUIPAGEINSERT_PROPSHEETPAGE: u32 = 3u32;
#[repr(C)]
pub struct PUBLISHERINFO {
pub dwMode: u32,
pub wMinoutlinePPEM: u16,
pub wMaxbitmapPPEM: u16,
}
impl ::core::marker::Copy for PUBLISHERINFO {}
impl ::core::clone::Clone for PUBLISHERINFO {
fn clone(&self) -> Self {
*self
}
}
pub const PUSHBUTTON_TYPE_CALLBACK: u32 = 1u32;
pub const PUSHBUTTON_TYPE_DLGPROC: u32 = 0u32;
pub const PUSHBUTTON_TYPE_HTCLRADJ: u32 = 2u32;
pub const PUSHBUTTON_TYPE_HTSETUP: u32 = 3u32;
pub type PageCountType = i32;
pub const FinalPageCount: PageCountType = 0i32;
pub const IntermediatePageCount: PageCountType = 1i32;
pub type PrintAsyncNotifyConversationStyle = i32;
pub const kBiDirectional: PrintAsyncNotifyConversationStyle = 0i32;
pub const kUniDirectional: PrintAsyncNotifyConversationStyle = 1i32;
pub type PrintAsyncNotifyError = i32;
pub const CHANNEL_CLOSED_BY_SERVER: PrintAsyncNotifyError = 1i32;
pub const CHANNEL_CLOSED_BY_ANOTHER_LISTENER: PrintAsyncNotifyError = 2i32;
pub const CHANNEL_CLOSED_BY_SAME_LISTENER: PrintAsyncNotifyError = 3i32;
pub const CHANNEL_RELEASED_BY_LISTENER: PrintAsyncNotifyError = 4i32;
pub const UNIRECTIONAL_NOTIFICATION_LOST: PrintAsyncNotifyError = 5i32;
pub const ASYNC_NOTIFICATION_FAILURE: PrintAsyncNotifyError = 6i32;
pub const NO_LISTENERS: PrintAsyncNotifyError = 7i32;
pub const CHANNEL_ALREADY_CLOSED: PrintAsyncNotifyError = 8i32;
pub const CHANNEL_ALREADY_OPENED: PrintAsyncNotifyError = 9i32;
pub const CHANNEL_WAITING_FOR_CLIENT_NOTIFICATION: PrintAsyncNotifyError = 10i32;
pub const CHANNEL_NOT_OPENED: PrintAsyncNotifyError = 11i32;
pub const ASYNC_CALL_ALREADY_PARKED: PrintAsyncNotifyError = 12i32;
pub const NOT_REGISTERED: PrintAsyncNotifyError = 13i32;
pub const ALREADY_UNREGISTERED: PrintAsyncNotifyError = 14i32;
pub const ALREADY_REGISTERED: PrintAsyncNotifyError = 15i32;
pub const CHANNEL_ACQUIRED: PrintAsyncNotifyError = 16i32;
pub const ASYNC_CALL_IN_PROGRESS: PrintAsyncNotifyError = 17i32;
pub const MAX_NOTIFICATION_SIZE_EXCEEDED: PrintAsyncNotifyError = 18i32;
pub const INTERNAL_NOTIFICATION_QUEUE_IS_FULL: PrintAsyncNotifyError = 19i32;
pub const INVALID_NOTIFICATION_TYPE: PrintAsyncNotifyError = 20i32;
pub const MAX_REGISTRATION_COUNT_EXCEEDED: PrintAsyncNotifyError = 21i32;
pub const MAX_CHANNEL_COUNT_EXCEEDED: PrintAsyncNotifyError = 22i32;
pub const LOCAL_ONLY_REGISTRATION: PrintAsyncNotifyError = 23i32;
pub const REMOTE_ONLY_REGISTRATION: PrintAsyncNotifyError = 24i32;
pub type PrintAsyncNotifyUserFilter = i32;
pub const kPerUser: PrintAsyncNotifyUserFilter = 0i32;
pub const kAllUsers: PrintAsyncNotifyUserFilter = 1i32;
pub type PrintJobStatus = i32;
pub const PrintJobStatus_Paused: PrintJobStatus = 1i32;
pub const PrintJobStatus_Error: PrintJobStatus = 2i32;
pub const PrintJobStatus_Deleting: PrintJobStatus = 4i32;
pub const PrintJobStatus_Spooling: PrintJobStatus = 8i32;
pub const PrintJobStatus_Printing: PrintJobStatus = 16i32;
pub const PrintJobStatus_Offline: PrintJobStatus = 32i32;
pub const PrintJobStatus_PaperOut: PrintJobStatus = 64i32;
pub const PrintJobStatus_Printed: PrintJobStatus = 128i32;
pub const PrintJobStatus_Deleted: PrintJobStatus = 256i32;
pub const PrintJobStatus_BlockedDeviceQueue: PrintJobStatus = 512i32;
pub const PrintJobStatus_UserIntervention: PrintJobStatus = 1024i32;
pub const PrintJobStatus_Restarted: PrintJobStatus = 2048i32;
pub const PrintJobStatus_Complete: PrintJobStatus = 4096i32;
pub const PrintJobStatus_Retained: PrintJobStatus = 8192i32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PrintNamedProperty {
pub propertyName: super::super::Foundation::PWSTR,
pub propertyValue: PrintPropertyValue,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PrintNamedProperty {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PrintNamedProperty {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PrintPropertiesCollection {
pub numberOfProperties: u32,
pub propertiesCollection: *mut PrintNamedProperty,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PrintPropertiesCollection {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PrintPropertiesCollection {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PrintPropertyValue {
pub ePropertyType: EPrintPropertyType,
pub value: PrintPropertyValue_0,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PrintPropertyValue {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PrintPropertyValue {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub union PrintPropertyValue_0 {
pub propertyByte: u8,
pub propertyString: super::super::Foundation::PWSTR,
pub propertyInt32: i32,
pub propertyInt64: i64,
pub propertyBlob: PrintPropertyValue_0_0,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PrintPropertyValue_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PrintPropertyValue_0 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PrintPropertyValue_0_0 {
pub cbBuf: u32,
pub pBuf: *mut ::core::ffi::c_void,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for PrintPropertyValue_0_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PrintPropertyValue_0_0 {
fn clone(&self) -> Self {
*self
}
}
pub const PrintSchemaAsyncOperation: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 1135802429, data2: 4338, data3: 18603, data4: [131, 27, 85, 253, 189, 189, 52, 164] };
pub type PrintSchemaConstrainedSetting = i32;
pub const PrintSchemaConstrainedSetting_None: PrintSchemaConstrainedSetting = 0i32;
pub const PrintSchemaConstrainedSetting_PrintTicket: PrintSchemaConstrainedSetting = 1i32;
pub const PrintSchemaConstrainedSetting_Admin: PrintSchemaConstrainedSetting = 2i32;
pub const PrintSchemaConstrainedSetting_Device: PrintSchemaConstrainedSetting = 3i32;
pub type PrintSchemaParameterDataType = i32;
pub const PrintSchemaParameterDataType_Integer: PrintSchemaParameterDataType = 0i32;
pub const PrintSchemaParameterDataType_NumericString: PrintSchemaParameterDataType = 1i32;
pub const PrintSchemaParameterDataType_String: PrintSchemaParameterDataType = 2i32;
pub type PrintSchemaSelectionType = i32;
pub const PrintSchemaSelectionType_PickOne: PrintSchemaSelectionType = 0i32;
pub const PrintSchemaSelectionType_PickMany: PrintSchemaSelectionType = 1i32;
pub const PrinterExtensionManager: ::windows_sys::core::GUID = ::windows_sys::core::GUID {
data1: 857432282,
data2: 40592,
data3: 19920,
data4: [156, 132, 234, 196, 230, 89, 182, 31],
};
pub const PrinterQueue: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 3948200496, data2: 31116, data3: 19614, data4: [180, 97, 41, 250, 208, 64, 57, 177] };
pub const PrinterQueueView: ::windows_sys::core::GUID = ::windows_sys::core::GUID { data1: 3948200497, data2: 31116, data3: 19614, data4: [180, 97, 41, 250, 208, 64, 57, 177] };
pub const QCP_DEVICEPROFILE: u32 = 0u32;
pub const QCP_PROFILEDISK: u32 = 2u32;
pub const QCP_PROFILEMEMORY: u32 = 1u32;
pub const QCP_SOURCEPROFILE: u32 = 1u32;
pub const RAWTCP: u32 = 1u32;
pub const REVERSE_PAGES_FOR_REVERSE_DUPLEX: u32 = 1u32;
pub const REVERSE_PRINT: u32 = 1u32;
pub const RIGHT_THEN_DOWN: u32 = 1u32;
#[cfg(feature = "Win32_Foundation")]
pub type ROUTER_NOTIFY_CALLBACK = ::core::option::Option<unsafe extern "system" fn(dwcommand: u32, pcontext: *const ::core::ffi::c_void, dwcolor: u32, pnofityinfo: *const PRINTER_NOTIFY_INFO, fdwflags: u32, pdwresult: *mut u32) -> super::super::Foundation::BOOL>;
pub const ROUTER_STOP_ROUTING: u32 = 2u32;
pub const ROUTER_SUCCESS: u32 = 1u32;
pub const ROUTER_UNKNOWN: u32 = 0u32;
pub const SERVER_ACCESS_ADMINISTER: u32 = 1u32;
pub const SERVER_ACCESS_ENUMERATE: u32 = 2u32;
pub const SERVER_NOTIFY_FIELD_PRINT_DRIVER_ISOLATION_GROUP: u32 = 0u32;
pub const SERVER_NOTIFY_TYPE: u32 = 2u32;
pub const SETOPTIONS_FLAG_KEEP_CONFLICT: u32 = 2u32;
pub const SETOPTIONS_FLAG_RESOLVE_CONFLICT: u32 = 1u32;
pub const SETOPTIONS_RESULT_CONFLICT_REMAINED: u32 = 2u32;
pub const SETOPTIONS_RESULT_CONFLICT_RESOLVED: u32 = 1u32;
pub const SETOPTIONS_RESULT_NO_CONFLICT: u32 = 0u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SETRESULT_INFO {
pub cbSize: u16,
pub wReserved: u16,
pub hSetResult: super::super::Foundation::HANDLE,
pub Result: super::super::Foundation::LRESULT,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for SETRESULT_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for SETRESULT_INFO {
fn clone(&self) -> Self {
*self
}
}
pub type SHIMOPTS = i32;
pub const PTSHIM_DEFAULT: SHIMOPTS = 0i32;
pub const PTSHIM_NOSNAPSHOT: SHIMOPTS = 1i32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SHOWUIPARAMS {
pub UIType: UI_TYPE,
pub MessageBoxParams: MESSAGEBOX_PARAMS,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for SHOWUIPARAMS {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for SHOWUIPARAMS {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct SIMULATE_CAPS_1 {
pub dwLevel: u32,
pub dwPageOrderFlags: u32,
pub dwNumberOfCopies: u32,
pub dwCollate: u32,
pub dwNupOptions: u32,
}
impl ::core::marker::Copy for SIMULATE_CAPS_1 {}
impl ::core::clone::Clone for SIMULATE_CAPS_1 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPLCLIENT_INFO_1 {
pub dwSize: u32,
pub pMachineName: super::super::Foundation::PWSTR,
pub pUserName: super::super::Foundation::PWSTR,
pub dwBuildNum: u32,
pub dwMajorVersion: u32,
pub dwMinorVersion: u32,
pub wProcessorArchitecture: u16,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for SPLCLIENT_INFO_1 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for SPLCLIENT_INFO_1 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPLCLIENT_INFO_3_VISTA {
pub cbSize: u32,
pub dwFlags: u32,
pub dwSize: u32,
pub pMachineName: super::super::Foundation::PWSTR,
pub pUserName: super::super::Foundation::PWSTR,
pub dwBuildNum: u32,
pub dwMajorVersion: u32,
pub dwMinorVersion: u32,
pub wProcessorArchitecture: u16,
pub hSplPrinter: u64,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for SPLCLIENT_INFO_3_VISTA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for SPLCLIENT_INFO_3_VISTA {
fn clone(&self) -> Self {
*self
}
}
pub const SPOOL_FILE_PERSISTENT: u32 = 1u32;
pub const SPOOL_FILE_TEMPORARY: u32 = 2u32;
pub const SR_OWNER: u32 = 0u32;
pub const SR_OWNER_PARENT: u32 = 1u32;
pub const SSP_STDPAGE1: u32 = 10001u32;
pub const SSP_STDPAGE2: u32 = 10002u32;
pub const SSP_TVPAGE: u32 = 10000u32;
pub const STRING_LANGPAIR: u32 = 4u32;
pub const STRING_MUIDLL: u32 = 2u32;
pub const STRING_NONE: u32 = 1u32;
pub const S_CONFLICT_RESOLVED: u32 = 262146u32;
pub const S_DEVCAP_OUTPUT_FULL_REPLACEMENT: ::windows_sys::core::HRESULT = 318465i32;
pub const S_NO_CONFLICT: u32 = 262145u32;
#[repr(C)]
pub struct TRANSDATA {
pub ubCodePageID: u8,
pub ubType: u8,
pub uCode: TRANSDATA_0,
}
impl ::core::marker::Copy for TRANSDATA {}
impl ::core::clone::Clone for TRANSDATA {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub union TRANSDATA_0 {
pub sCode: i16,
pub ubCode: u8,
pub ubPairs: [u8; 2],
}
impl ::core::marker::Copy for TRANSDATA_0 {}
impl ::core::clone::Clone for TRANSDATA_0 {
fn clone(&self) -> Self {
*self
}
}
pub const TTDOWNLOAD_BITMAP: u32 = 2u32;
pub const TTDOWNLOAD_DONTCARE: u32 = 0u32;
pub const TTDOWNLOAD_GRAPHICS: u32 = 1u32;
pub const TTDOWNLOAD_TTOUTLINE: u32 = 3u32;
pub const TVOT_2STATES: u32 = 0u32;
pub const TVOT_3STATES: u32 = 1u32;
pub const TVOT_CHKBOX: u32 = 9u32;
pub const TVOT_COMBOBOX: u32 = 6u32;
pub const TVOT_EDITBOX: u32 = 7u32;
pub const TVOT_LISTBOX: u32 = 5u32;
pub const TVOT_NSTATES_EX: u32 = 10u32;
pub const TVOT_PUSHBUTTON: u32 = 8u32;
pub const TVOT_SCROLLBAR: u32 = 4u32;
pub const TVOT_TRACKBAR: u32 = 3u32;
pub const TVOT_UDARROW: u32 = 2u32;
pub const TYPE_GLYPHHANDLE: u32 = 3u32;
pub const TYPE_GLYPHID: u32 = 4u32;
pub const TYPE_TRANSDATA: u32 = 2u32;
pub const TYPE_UNICODE: u32 = 1u32;
#[repr(C)]
pub struct UFF_FILEHEADER {
pub dwSignature: u32,
pub dwVersion: u32,
pub dwSize: u32,
pub nFonts: u32,
pub nGlyphSets: u32,
pub nVarData: u32,
pub offFontDir: u32,
pub dwFlags: u32,
pub dwReserved: [u32; 4],
}
impl ::core::marker::Copy for UFF_FILEHEADER {}
impl ::core::clone::Clone for UFF_FILEHEADER {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct UFF_FONTDIRECTORY {
pub dwSignature: u32,
pub wSize: u16,
pub wFontID: u16,
pub sGlyphID: i16,
pub wFlags: u16,
pub dwInstallerSig: u32,
pub offFontName: u32,
pub offCartridgeName: u32,
pub offFontData: u32,
pub offGlyphData: u32,
pub offVarData: u32,
}
impl ::core::marker::Copy for UFF_FONTDIRECTORY {}
impl ::core::clone::Clone for UFF_FONTDIRECTORY {
fn clone(&self) -> Self {
*self
}
}
pub const UFF_VERSION_NUMBER: u32 = 65537u32;
pub const UFM_CART: u32 = 2u32;
pub const UFM_SCALABLE: u32 = 4u32;
pub const UFM_SOFT: u32 = 1u32;
pub const UFOFLAG_TTDOWNLOAD_BITMAP: u32 = 2u32;
pub const UFOFLAG_TTDOWNLOAD_TTOUTLINE: u32 = 4u32;
pub const UFOFLAG_TTFONT: u32 = 1u32;
pub const UFOFLAG_TTOUTLINE_BOLD_SIM: u32 = 8u32;
pub const UFOFLAG_TTOUTLINE_ITALIC_SIM: u32 = 16u32;
pub const UFOFLAG_TTOUTLINE_VERTICAL: u32 = 32u32;
pub const UFOFLAG_TTSUBSTITUTED: u32 = 64u32;
pub const UFO_GETINFO_FONTOBJ: u32 = 1u32;
pub const UFO_GETINFO_GLYPHBITMAP: u32 = 3u32;
pub const UFO_GETINFO_GLYPHSTRING: u32 = 2u32;
pub const UFO_GETINFO_GLYPHWIDTH: u32 = 4u32;
pub const UFO_GETINFO_MEMORY: u32 = 5u32;
pub const UFO_GETINFO_STDVARIABLE: u32 = 6u32;
pub type UI_TYPE = i32;
pub const kMessageBox: UI_TYPE = 0i32;
#[repr(C)]
pub struct UNIDRVINFO {
pub dwSize: u32,
pub flGenFlags: u32,
pub wType: u16,
pub fCaps: u16,
pub wXRes: u16,
pub wYRes: u16,
pub sYAdjust: i16,
pub sYMoved: i16,
pub wPrivateData: u16,
pub sShift: i16,
pub SelectFont: INVOC,
pub UnSelectFont: INVOC,
pub wReserved: [u16; 4],
}
impl ::core::marker::Copy for UNIDRVINFO {}
impl ::core::clone::Clone for UNIDRVINFO {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct UNIDRV_PRIVATE_DEVMODE {
pub wReserved: [u16; 4],
pub wSize: u16,
}
impl ::core::marker::Copy for UNIDRV_PRIVATE_DEVMODE {}
impl ::core::clone::Clone for UNIDRV_PRIVATE_DEVMODE {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct UNIFM_HDR {
pub dwSize: u32,
pub dwVersion: u32,
pub ulDefaultCodepage: u32,
pub lGlyphSetDataRCID: i32,
pub loUnidrvInfo: u32,
pub loIFIMetrics: u32,
pub loExtTextMetric: u32,
pub loWidthTable: u32,
pub loKernPair: u32,
pub dwReserved: [u32; 2],
}
impl ::core::marker::Copy for UNIFM_HDR {}
impl ::core::clone::Clone for UNIFM_HDR {
fn clone(&self) -> Self {
*self
}
}
pub const UNIFM_VERSION_1_0: u32 = 65536u32;
#[repr(C)]
pub struct UNI_CODEPAGEINFO {
pub dwCodePage: u32,
pub SelectSymbolSet: INVOC,
pub UnSelectSymbolSet: INVOC,
}
impl ::core::marker::Copy for UNI_CODEPAGEINFO {}
impl ::core::clone::Clone for UNI_CODEPAGEINFO {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct UNI_GLYPHSETDATA {
pub dwSize: u32,
pub dwVersion: u32,
pub dwFlags: u32,
pub lPredefinedID: i32,
pub dwGlyphCount: u32,
pub dwRunCount: u32,
pub loRunOffset: u32,
pub dwCodePageCount: u32,
pub loCodePageOffset: u32,
pub loMapTableOffset: u32,
pub dwReserved: [u32; 2],
}
impl ::core::marker::Copy for UNI_GLYPHSETDATA {}
impl ::core::clone::Clone for UNI_GLYPHSETDATA {
fn clone(&self) -> Self {
*self
}
}
pub const UNI_GLYPHSETDATA_VERSION_1_0: u32 = 65536u32;
pub const UNKNOWN_PROTOCOL: u32 = 0u32;
pub const UPDP_CHECK_DRIVERSTORE: u32 = 4u32;
pub const UPDP_SILENT_UPLOAD: u32 = 1u32;
pub const UPDP_UPLOAD_ALWAYS: u32 = 2u32;
pub const USBPRINT_IOCTL_INDEX: u32 = 0u32;
pub const USB_PRINTER_INTERFACE_CLASSIC: u32 = 1u32;
pub const USB_PRINTER_INTERFACE_DUAL: u32 = 3u32;
pub const USB_PRINTER_INTERFACE_IPP: u32 = 2u32;
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct USERDATA {
pub dwSize: u32,
pub dwItemID: usize,
pub pKeyWordName: super::super::Foundation::PSTR,
pub dwReserved: [u32; 8],
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for USERDATA {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for USERDATA {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct WIDTHRUN {
pub wStartGlyph: u16,
pub wGlyphCount: u16,
pub loCharWidthOffset: u32,
}
impl ::core::marker::Copy for WIDTHRUN {}
impl ::core::clone::Clone for WIDTHRUN {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct WIDTHTABLE {
pub dwSize: u32,
pub dwRunNum: u32,
pub WidthRun: [WIDTHRUN; 1],
}
impl ::core::marker::Copy for WIDTHTABLE {}
impl ::core::clone::Clone for WIDTHTABLE {
fn clone(&self) -> Self {
*self
}
}
pub const WM_FI_FILENAME: u32 = 900u32;
pub type XPSRAS_BACKGROUND_COLOR = i32;
pub const XPSRAS_BACKGROUND_COLOR_TRANSPARENT: XPSRAS_BACKGROUND_COLOR = 0i32;
pub const XPSRAS_BACKGROUND_COLOR_OPAQUE: XPSRAS_BACKGROUND_COLOR = 1i32;
pub type XPSRAS_PIXEL_FORMAT = i32;
pub const XPSRAS_PIXEL_FORMAT_32BPP_PBGRA_UINT_SRGB: XPSRAS_PIXEL_FORMAT = 1i32;
pub const XPSRAS_PIXEL_FORMAT_64BPP_PRGBA_HALF_SCRGB: XPSRAS_PIXEL_FORMAT = 2i32;
pub const XPSRAS_PIXEL_FORMAT_128BPP_PRGBA_FLOAT_SCRGB: XPSRAS_PIXEL_FORMAT = 3i32;
pub type XPSRAS_RENDERING_MODE = i32;
pub const XPSRAS_RENDERING_MODE_ANTIALIASED: XPSRAS_RENDERING_MODE = 0i32;
pub const XPSRAS_RENDERING_MODE_ALIASED: XPSRAS_RENDERING_MODE = 1i32;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_UI_WindowsAndMessaging"))]
pub type _CPSUICALLBACK = ::core::option::Option<unsafe extern "system" fn(pcpsuicbparam: *mut CPSUICBPARAM) -> i32>;
#[repr(C)]
pub struct _SPLCLIENT_INFO_2_V1 {
pub hSplPrinter: usize,
}
impl ::core::marker::Copy for _SPLCLIENT_INFO_2_V1 {}
impl ::core::clone::Clone for _SPLCLIENT_INFO_2_V1 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
pub struct _SPLCLIENT_INFO_2_V2 {
pub hSplPrinter: u64,
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::marker::Copy for _SPLCLIENT_INFO_2_V2 {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::clone::Clone for _SPLCLIENT_INFO_2_V2 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
pub struct _SPLCLIENT_INFO_2_V2 {
pub hSplPrinter: u32,
}
#[cfg(any(target_arch = "x86",))]
impl ::core::marker::Copy for _SPLCLIENT_INFO_2_V2 {}
#[cfg(any(target_arch = "x86",))]
impl ::core::clone::Clone for _SPLCLIENT_INFO_2_V2 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
pub struct _SPLCLIENT_INFO_2_V3 {
pub hSplPrinter: u64,
}
impl ::core::marker::Copy for _SPLCLIENT_INFO_2_V3 {}
impl ::core::clone::Clone for _SPLCLIENT_INFO_2_V3 {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct __MIDL___MIDL_itf_imgerror_0000_0000_0001 {
pub description: super::super::Foundation::BSTR,
pub guid: ::windows_sys::core::GUID,
pub helpContext: u32,
pub helpFile: super::super::Foundation::BSTR,
pub source: super::super::Foundation::BSTR,
pub devDescription: super::super::Foundation::BSTR,
pub errorID: ::windows_sys::core::GUID,
pub cUserParameters: u32,
pub aUserParameters: *mut super::super::Foundation::BSTR,
pub userFallback: super::super::Foundation::BSTR,
pub exceptionID: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for __MIDL___MIDL_itf_imgerror_0000_0000_0001 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for __MIDL___MIDL_itf_imgerror_0000_0000_0001 {
fn clone(&self) -> Self {
*self
}
}
|
use std::collections::HashMap;
#[derive(Debug, PartialEq, Clone)]
pub enum JsonValue {
Null,
Boolean(bool),
Str(String),
Num(f64),
Array(Vec<JsonValue>),
Object(HashMap<String, JsonValue>),
}
|
// Copyright 2017 rust-ipfs-api Developers
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
//
//! Rust library for connecting to the IPFS HTTP API using Hyper/Actix.
//!
//! ## Usage
//!
//! ```toml
//! [dependencies]
//! ipfs-api = "0.11.0"
//! ```
//! ### Feature Flags
//!
//! You can use `actix-web` as a backend instead of `hyper`.
//!
//! ```toml
//! [dependencies]
//! ipfs-api = { version = "0.11.0", features = ["with-actix"], default-features = false }
//! ```
//!
//! You also have the option of using [`rustls`](https://crates.io/crates/rustls)
//! instead of native tls:
//!
//! ```toml
//! [dependencies]
//! ipfs-api = { version = "0.11.0", features = ["with-hyper-rustls"], default-features = false }
//! ```
//!
//! To enable the builder pattern (default) use the `with-builder` feature:
//!
//! ```toml
//! [dependencies]
//! ipfs-api = { version = "0.11.0", features = ["with-hyper-rustls", "with-builder"], default-features = false }
//! ```
//!
//! ## Examples
//!
//! ### Writing a file to IPFS
//!
//! #### With Hyper
//!
//! ```no_run
//! use ipfs_api::{IpfsApi, IpfsClient};
//! use std::io::Cursor;
//!
//! #[tokio::main]
//! async fn main() {
//! let client = IpfsClient::default();
//! let data = Cursor::new("Hello World!");
//!
//! match client.add(data).await {
//! Ok(res) => println!("{}", res.hash),
//! Err(e) => eprintln!("error adding file: {}", e)
//! }
//! }
//! ```
//!
//! #### With Actix
//!
//! ```no_run
//! use ipfs_api::{IpfsApi, IpfsClient};
//! use std::io::Cursor;
//!
//! #[actix_rt::main]
//! async fn main() {
//! let client = IpfsClient::default();
//! let data = Cursor::new("Hello World!");
//!
//! match client.add(data).await {
//! Ok(res) => println!("{}", res.hash),
//! Err(e) => eprintln!("error adding file: {}", e)
//! }
//! }
//! ```
//!
//! ### Reading a file from IPFS
//!
//! #### With Hyper
//!
//! ```no_run
//! use futures::TryStreamExt;
//! use ipfs_api::{IpfsApi, IpfsClient};
//! use std::io::{self, Write};
//!
//! #[tokio::main]
//! async fn main() {
//! let client = IpfsClient::default();
//!
//! match client
//! .get("/test/file.json")
//! .map_ok(|chunk| chunk.to_vec())
//! .try_concat()
//! .await
//! {
//! Ok(res) => {
//! let out = io::stdout();
//! let mut out = out.lock();
//!
//! out.write_all(&res).unwrap();
//! }
//! Err(e) => eprintln!("error getting file: {}", e)
//! }
//! }
//! ```
//!
//! #### With Actix
//!
//! ```no_run
//! use futures::TryStreamExt;
//! use ipfs_api::{IpfsApi, IpfsClient};
//! use std::io::{self, Write};
//!
//! #[actix_rt::main]
//! async fn main() {
//! let client = IpfsClient::default();
//!
//! match client
//! .get("/test/file.json")
//! .map_ok(|chunk| chunk.to_vec())
//! .try_concat()
//! .await
//! {
//! Ok(res) => {
//! let out = io::stdout();
//! let mut out = out.lock();
//!
//! out.write_all(&res).unwrap();
//! }
//! Err(e) => eprintln!("error getting file: {}", e)
//! }
//! }
//! ```
//!
//! ### Additional Examples
//!
//! There are also a bunch of examples included in the project, which
//! I used for testing
//!
//! For a list of examples, run:
//!
//! ```sh
//! $ cargo run --example
//! ```
//!
//! You can run any of the examples with cargo:
//!
//! ```sh
//! $ cargo run --example add_file
//! ```
//!
#[cfg(feature = "with-hyper")]
pub use ipfs_api_backend_hyper::*;
#[cfg(feature = "with-actix")]
pub use ipfs_api_backend_actix::*;
#[cfg(not(any(feature = "with-actix", feature = "with-hyper")))]
compile_error!("Pick exactly one of these features: with-hyper, with-actix");
|
/*
* Firecracker API
*
* RESTful public-facing API. The API is accessible through HTTP calls on specific URLs carrying JSON modeled data. The transport medium is a Unix Domain Socket.
*
* The version of the OpenAPI document: 0.25.0
* Contact: compute-capsule@amazon.com
* Generated by: https://openapi-generator.tech
*/
/// Vm : Defines the microVM running state. It is especially useful in the snapshotting context.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Vm {
#[serde(rename = "state")]
pub state: State,
}
impl Vm {
/// Defines the microVM running state. It is especially useful in the snapshotting context.
pub fn new(state: State) -> Vm {
Vm { state }
}
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum State {
#[serde(rename = "Paused")]
Paused,
#[serde(rename = "Resumed")]
Resumed,
}
|
use super::*;
type FaultResult = Result<(), Fault>;
fn init_logger() {
let _ = env_logger::builder().is_test(true).try_init();
}
#[test]
fn test_advancing() -> FaultResult {
init_logger();
let mut ic = IntCodeComputer::from_str("1,0,0,0,2,0,0,0,99")?;
ic.advance(4)?;
assert_eq!(ic.program_counter(), 4);
ic.advance(2)?;
assert_eq!(ic.program_counter(), 6);
ic.advance(1)?;
assert_eq!(ic.program_counter(), 7);
let mut ic = IntCodeComputer {
pc: MEMORY_SIZE - 1,
input: Vec::new(),
memory: [None; MEMORY_SIZE],
output: Vec::new(),
waiting_on_input: false,
original_memory: [None; MEMORY_SIZE],
};
// Allow advancing to equal to the memory size (allow halt to be the final instruction)
ic.advance(1)?;
assert_eq!(ic.program_counter(), MEMORY_SIZE);
// Ensure we can't advance any further without triggering an error
assert_eq!(ic.advance(1), Err(Fault::MemoryExceeded));
Ok(())
}
#[test]
fn test_memory_retrieval() -> FaultResult {
init_logger();
let mut ic = IntCodeComputer::default();
ic.store(7, 45)?;
assert_eq!(ic.mem_read(7)?, 45);
assert_eq!(ic.mem_read(1), Err(Fault::MissingMemory(0, 1)));
assert_eq!(
ic.mem_read((MEMORY_SIZE + 1).try_into().unwrap()),
Err(Fault::MemoryExceeded)
);
Ok(())
}
#[test]
fn test_memory_storage() -> FaultResult {
init_logger();
let mut ic = IntCodeComputer::default();
ic.store(0, 100)?;
assert_eq!(ic.mem_read(0)?, 100);
assert_eq!(
ic.store((MEMORY_SIZE + 1).try_into().unwrap(), 6000),
Err(Fault::MemoryExceeded)
);
Ok(())
}
#[test]
fn test_halt_checking() -> FaultResult {
init_logger();
let mut ic = IntCodeComputer::default();
// Setup our memory so we can advance through a couple of operation states
ic.store(0, 1)?;
ic.store(1, 99)?;
ic.store(2, 1)?;
assert!(!ic.is_halted());
ic.advance(1)?;
assert!(ic.is_halted());
ic.advance(1)?;
assert!(!ic.is_halted());
Ok(())
}
#[test]
fn test_op_parsing() -> FaultResult {
init_logger();
let mut ic = IntCodeComputer::default();
// Setup our memory so we can advance through a couple of operation states
ic.store(0, 1)?;
ic.store(1, 2)?;
ic.store(2, 3)?;
ic.store(3, 4)?;
ic.store(4, 5)?;
ic.store(5, 6)?;
ic.store(6, 7)?;
ic.store(7, 8)?;
ic.store(8, 99)?;
ic.store(10, 7500)?;
assert_eq!(ic.current_op()?, Operation::Add(0));
ic.advance(1)?;
assert_eq!(ic.current_op()?, Operation::Mul(0));
ic.advance(1)?;
assert_eq!(ic.current_op()?, Operation::Input);
ic.advance(1)?;
assert_eq!(ic.current_op()?, Operation::Output(0));
ic.advance(1)?;
assert_eq!(ic.current_op()?, Operation::JumpIfTrue(0));
ic.advance(1)?;
assert_eq!(ic.current_op()?, Operation::JumpIfFalse(0));
ic.advance(1)?;
assert_eq!(ic.current_op()?, Operation::LessThan(0));
ic.advance(1)?;
assert_eq!(ic.current_op()?, Operation::Equals(0));
ic.advance(1)?;
assert_eq!(ic.current_op()?, Operation::Halt);
ic.advance(1)?;
assert_eq!(ic.current_op(), Err(Fault::UninitializedOperation(9)));
ic.advance(1)?;
assert_eq!(ic.current_op(), Err(Fault::UnknownOperation(10, 7500)));
Ok(())
}
#[test]
fn test_prog_parsing() {
init_logger();
let sample_prog = "1,2,3,4,5";
let ic = IntCodeComputer::from_str(sample_prog).unwrap();
assert_eq!(ic.memory_str(), sample_prog);
}
#[test]
fn test_trailing_whitespace() {
init_logger();
let sample_prog = "1,2,3,100,0\n";
let ic = IntCodeComputer::from_str(sample_prog).unwrap();
assert_eq!(ic.memory_str(), "1,2,3,100,0");
}
#[test]
fn test_addition_step() -> FaultResult {
init_logger();
let sample_prog = "1,4,5,6,10,20";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
assert_eq!(ic.memory_str(), sample_prog);
assert_eq!(ic.current_op()?, Operation::Add(0));
ic.step()?;
assert_eq!(ic.program_counter(), 4);
assert_eq!(ic.memory_str(), "1,4,5,6,10,20,30");
Ok(())
}
#[test]
fn test_multiplication_step() -> FaultResult {
init_logger();
let sample_prog = "2,4,5,6,10,20";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
assert_eq!(ic.memory_str(), sample_prog);
assert_eq!(ic.current_op()?, Operation::Mul(0));
ic.step()?;
assert_eq!(ic.program_counter(), 4);
assert_eq!(ic.memory_str(), "2,4,5,6,10,20,200");
Ok(())
}
#[test]
fn test_input_step() -> FaultResult {
init_logger();
let sample_prog = "3,3,99";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
ic.add_input(vec![-832]);
assert_eq!(ic.memory_str(), sample_prog);
assert_eq!(ic.current_op()?, Operation::Input);
ic.step()?;
assert_eq!(ic.program_counter(), 2);
assert_eq!(ic.memory_str(), "3,3,99,-832");
Ok(())
}
#[test]
fn test_output_step() -> FaultResult {
init_logger();
let sample_prog = "4,3,99,9723";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
assert_eq!(ic.memory_str(), sample_prog);
assert_eq!(ic.current_op()?, Operation::Output(0));
ic.step()?;
assert_eq!(ic.program_counter(), 2);
assert_eq!(ic.output(), vec![9723]);
// Output should clear after being pulled
assert_eq!(ic.output(), vec![]);
Ok(())
}
#[test]
fn test_jump_if_true_step() -> FaultResult {
init_logger();
let sample_prog = "5,0,5,1000,99,45";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
assert_eq!(ic.memory_str(), sample_prog);
assert_eq!(ic.current_op()?, Operation::JumpIfTrue(0));
ic.step()?;
assert_eq!(ic.program_counter(), 45);
let sample_prog = "105,0,500,99";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
assert_eq!(ic.memory_str(), sample_prog);
assert_eq!(ic.current_op()?, Operation::JumpIfTrue(1));
ic.step()?;
assert_eq!(ic.program_counter(), 3);
Ok(())
}
#[test]
fn test_jump_if_false_step() -> FaultResult {
init_logger();
let sample_prog = "106,0,3,8,1,2,3,1,99";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
assert_eq!(ic.memory_str(), sample_prog);
assert_eq!(ic.current_op()?, Operation::JumpIfFalse(1));
ic.step()?;
assert_eq!(ic.program_counter(), 8);
let sample_prog = "1006,0,23,99";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
assert_eq!(ic.memory_str(), sample_prog);
assert_eq!(ic.current_op()?, Operation::JumpIfFalse(10));
ic.step()?;
assert_eq!(ic.program_counter(), 3);
Ok(())
}
#[test]
fn test_less_than_step() -> FaultResult {
init_logger();
let sample_prog = "7,5,6,4,99,2,20";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
assert_eq!(ic.memory_str(), sample_prog);
assert_eq!(ic.current_op()?, Operation::LessThan(0));
ic.step()?;
assert_eq!(ic.program_counter(), 4);
assert_eq!(ic.memory_str(), "7,5,6,4,1,2,20");
let sample_prog = "7,5,6,4,99,20,20";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
assert_eq!(ic.memory_str(), sample_prog);
assert_eq!(ic.current_op()?, Operation::LessThan(0));
ic.step()?;
assert_eq!(ic.program_counter(), 4);
assert_eq!(ic.memory_str(), "7,5,6,4,0,20,20");
Ok(())
}
#[test]
fn test_equals_step() -> FaultResult {
init_logger();
let sample_prog = "1108,10,10,4,99";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
assert_eq!(ic.memory_str(), sample_prog);
assert_eq!(ic.current_op()?, Operation::Equals(11));
ic.step()?;
assert_eq!(ic.program_counter(), 4);
assert_eq!(ic.memory_str(), "1108,10,10,4,1");
let sample_prog = "1008,5,5,4,99,100";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
assert_eq!(ic.memory_str(), sample_prog);
assert_eq!(ic.current_op()?, Operation::Equals(10));
ic.step()?;
assert_eq!(ic.program_counter(), 4);
assert_eq!(ic.memory_str(), "1008,5,5,4,0,100");
Ok(())
}
#[test]
fn test_halt_step() -> FaultResult {
init_logger();
let sample_prog = "99";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
assert_eq!(ic.memory_str(), sample_prog);
assert_eq!(ic.current_op()?, Operation::Halt);
ic.step()?;
assert_eq!(ic.memory_str(), "99");
assert_eq!(ic.program_counter(), 1);
Ok(())
}
// This is the test program walked through by the advent challenge
#[test]
fn test_stepping_sample_prog() -> FaultResult {
init_logger();
let sample_prog = "1,9,10,3,2,3,11,0,99,30,40,50";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
ic.step()?;
assert_eq!(ic.memory_str(), "1,9,10,70,2,3,11,0,99,30,40,50");
assert_eq!(ic.program_counter(), 4);
ic.step()?;
assert_eq!(ic.memory_str(), "3500,9,10,70,2,3,11,0,99,30,40,50");
assert_eq!(ic.program_counter(), 8);
// This is the halt instruction and should also complete successfully, termination of
// execution is tested via the run() function.
ic.step()?;
Ok(())
}
// Test the same program but rather than stepping just run it
#[test]
fn test_running_sample_prog() -> FaultResult {
init_logger();
let sample_prog = "1,9,10,3,2,3,11,0,99,30,40,50";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
ic.run()?;
assert_eq!(ic.memory_str(), "3500,9,10,70,2,3,11,0,99,30,40,50");
Ok(())
}
#[test]
fn test_additional_progs() -> FaultResult {
init_logger();
let programs: [(&'static str, &'static str); 4] = [
("1,0,0,0,99", "2,0,0,0,99"),
("2,3,0,3,99", "2,3,0,6,99"),
("2,4,4,5,99,0", "2,4,4,5,99,9801"),
("1,1,1,4,99,5,6,0,99", "30,1,1,4,2,5,6,0,99"),
];
for (prog, result) in programs.iter() {
let mut ic = IntCodeComputer::from_str(prog)?;
ic.run()?;
assert_eq!(ic.memory_str(), result.to_string());
}
Ok(())
}
#[test]
fn test_input_output_program() -> FaultResult {
init_logger();
let sample_prog = "3,0,4,0,99";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
ic.add_input(vec![673]);
ic.run()?;
assert_eq!(ic.output(), vec![673]);
Ok(())
}
#[test]
fn test_parameter_mode_samples() -> FaultResult {
init_logger();
let sample_prog = "1002,4,3,4,33";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
ic.run()?;
assert_eq!(ic.memory_str(), "1002,4,3,4,99");
Ok(())
}
#[test]
fn test_jump_instruction_samples1() -> FaultResult {
init_logger();
let sample_prog = "3,9,8,9,10,9,4,9,99,-1,8";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
ic.add_input(vec![4]);
ic.run()?;
assert_eq!(ic.output(), vec![0]);
ic.reset();
ic.add_input(vec![8]);
ic.run()?;
assert_eq!(ic.output(), vec![1]);
Ok(())
}
#[test]
fn test_jump_instruction_samples2() -> FaultResult {
init_logger();
let sample_prog = "3,3,1108,-1,8,3,4,3,99";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
ic.add_input(vec![-10]);
ic.run()?;
assert_eq!(ic.output(), vec![0]);
ic.reset();
ic.add_input(vec![8]);
ic.run()?;
assert_eq!(ic.output(), vec![1]);
Ok(())
}
#[test]
fn test_jump_instruction_samples3() -> FaultResult {
init_logger();
let sample_prog = "3,12,6,12,15,1,13,14,13,4,13,99,-1,0,1,9";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
ic.add_input(vec![0]);
ic.run()?;
assert_eq!(ic.output(), vec![0]);
ic.reset();
ic.add_input(vec![129]);
ic.run()?;
assert_eq!(ic.output(), vec![1]);
Ok(())
}
#[test]
fn test_jump_instruction_samples4() -> FaultResult {
init_logger();
let sample_prog = "3,3,1105,-1,9,1101,0,0,12,4,12,99,1";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
ic.add_input(vec![0]);
ic.run()?;
assert_eq!(ic.output(), vec![0]);
ic.reset();
ic.add_input(vec![129]);
ic.run()?;
assert_eq!(ic.output(), vec![1]);
Ok(())
}
#[test]
fn test_jump_instruction_samples5() -> FaultResult {
init_logger();
let sample_prog = "3,21,1008,21,8,20,1005,20,22,107,8,21,20,1006,20,31,1106,0,36,98,0,0,1002,21,125,20,4,20,1105,1,46,104,999,1105,1,46,1101,1000,1,20,4,20,1105,1,46,98,99";
let mut ic = IntCodeComputer::from_str(sample_prog)?;
ic.add_input(vec![5]);
ic.run()?;
assert_eq!(ic.output(), vec![999]);
ic.reset();
ic.add_input(vec![8]);
ic.run()?;
assert_eq!(ic.output(), vec![1000]);
ic.reset();
ic.add_input(vec![92]);
ic.run()?;
assert_eq!(ic.output(), vec![1001]);
Ok(())
}
#[test]
fn test_system_reset() -> FaultResult {
init_logger();
let prog = "1,8,4,1,2,2,1,4,99";
let mut ic = IntCodeComputer::from_str(&prog)?;
ic.run()?;
assert_eq!(ic.memory_str(), "1,101,4,1,404,2,1,4,99");
assert_eq!(ic.program_counter(), 8);
ic.reset();
assert_eq!(ic.memory_str(), prog);
assert_eq!(ic.program_counter(), 0);
Ok(())
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.