outlook_mapi_sys/

bindings.rs

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.

// Bindings generated by `windows-bindgen` 0.60.0

#[inline]
pub unsafe fn BuildDisplayTable<P3>(
    lpallocatebuffer: LPALLOCATEBUFFER,
    lpallocatemore: LPALLOCATEMORE,
    lpfreebuffer: LPFREEBUFFER,
    lpmalloc: P3,
    hinstance: windows::Win32::Foundation::HINSTANCE,
    cpages: u32,
    lppage: *mut DTPAGE,
    ulflags: u32,
    lpptable: *mut Option<IMAPITable>,
    lpptbldata: *mut Option<ITableData>,
) -> windows_core::Result<()>
where
    P3: windows_core::Param<windows::Win32::System::Com::IMalloc>,
{
    windows_link::link!("mapi32" "system" fn BuildDisplayTable(lpallocatebuffer : LPALLOCATEBUFFER, lpallocatemore : LPALLOCATEMORE, lpfreebuffer : LPFREEBUFFER, lpmalloc : * mut core::ffi::c_void, hinstance : windows::Win32::Foundation:: HINSTANCE, cpages : u32, lppage : *mut DTPAGE, ulflags : u32, lpptable : *mut * mut core::ffi::c_void, lpptbldata : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        BuildDisplayTable(
            lpallocatebuffer,
            lpallocatemore,
            lpfreebuffer,
            lpmalloc.param().abi(),
            hinstance,
            cpages,
            lppage as _,
            ulflags,
            core::mem::transmute(lpptable),
            core::mem::transmute(lpptbldata),
        )
        .ok()
    }
}
#[inline]
pub unsafe fn ChangeIdleRoutine(
    ftg: *mut core::ffi::c_void,
    lpfnidle: PFNIDLE,
    lpvidleparam: *mut core::ffi::c_void,
    priidle: i16,
    csecidle: u32,
    iroidle: u16,
    ircidle: u16,
) {
    windows_link::link!("mapi32" "system" fn ChangeIdleRoutine(ftg : *mut core::ffi::c_void, lpfnidle : PFNIDLE, lpvidleparam : *mut core::ffi::c_void, priidle : i16, csecidle : u32, iroidle : u16, ircidle : u16));
    unsafe {
        ChangeIdleRoutine(
            ftg as _,
            lpfnidle,
            lpvidleparam as _,
            priidle,
            csecidle,
            iroidle,
            ircidle,
        )
    }
}
#[inline]
pub unsafe fn CloseIMsgSession(lpmsgsess: windows::Win32::Storage::Imapi::LPMSGSESS) {
    windows_link::link!("mapi32" "system" fn CloseIMsgSession(lpmsgsess : windows::Win32::Storage::Imapi:: LPMSGSESS));
    unsafe { CloseIMsgSession(lpmsgsess) }
}
#[inline]
pub unsafe fn CreateIProp(
    lpinterface: *mut windows_core::GUID,
    lpallocatebuffer: LPALLOCATEBUFFER,
    lpallocatemore: LPALLOCATEMORE,
    lpfreebuffer: LPFREEBUFFER,
    lpvreserved: *mut core::ffi::c_void,
    lpppropdata: *mut Option<IPropData>,
) -> i32 {
    windows_link::link!("mapi32" "system" fn CreateIProp(lpinterface : *mut windows_core::GUID, lpallocatebuffer : LPALLOCATEBUFFER, lpallocatemore : LPALLOCATEMORE, lpfreebuffer : LPFREEBUFFER, lpvreserved : *mut core::ffi::c_void, lpppropdata : *mut * mut core::ffi::c_void) -> i32);
    unsafe {
        CreateIProp(
            lpinterface as _,
            lpallocatebuffer,
            lpallocatemore,
            lpfreebuffer,
            lpvreserved as _,
            core::mem::transmute(lpppropdata),
        )
    }
}
#[inline]
pub unsafe fn CreateTable(
    lpinterface: *mut windows_core::GUID,
    lpallocatebuffer: LPALLOCATEBUFFER,
    lpallocatemore: LPALLOCATEMORE,
    lpfreebuffer: LPFREEBUFFER,
    lpvreserved: *mut core::ffi::c_void,
    ultabletype: u32,
    ulproptagindexcolumn: u32,
    lpsproptagarraycolumns: *mut SPropTagArray,
    lpptabledata: *mut Option<ITableData>,
) -> i32 {
    windows_link::link!("mapi32" "system" fn CreateTable(lpinterface : *mut windows_core::GUID, lpallocatebuffer : LPALLOCATEBUFFER, lpallocatemore : LPALLOCATEMORE, lpfreebuffer : LPFREEBUFFER, lpvreserved : *mut core::ffi::c_void, ultabletype : u32, ulproptagindexcolumn : u32, lpsproptagarraycolumns : *mut SPropTagArray, lpptabledata : *mut * mut core::ffi::c_void) -> i32);
    unsafe {
        CreateTable(
            lpinterface as _,
            lpallocatebuffer,
            lpallocatemore,
            lpfreebuffer,
            lpvreserved as _,
            ultabletype,
            ulproptagindexcolumn,
            lpsproptagarraycolumns as _,
            core::mem::transmute(lpptabledata),
        )
    }
}
#[inline]
pub unsafe fn DeinitMapiUtil() {
    windows_link::link!("mapi32" "system" fn DeinitMapiUtil());
    unsafe { DeinitMapiUtil() }
}
#[inline]
pub unsafe fn DeregisterIdleRoutine(ftg: *mut core::ffi::c_void) {
    windows_link::link!("mapi32" "system" fn DeregisterIdleRoutine(ftg : *mut core::ffi::c_void));
    unsafe { DeregisterIdleRoutine(ftg as _) }
}
#[inline]
pub unsafe fn EnableIdleRoutine(ftg: *mut core::ffi::c_void, fenable: bool) {
    windows_link::link!("mapi32" "system" fn EnableIdleRoutine(ftg : *mut core::ffi::c_void, fenable : windows_core::BOOL));
    unsafe { EnableIdleRoutine(ftg as _, fenable.into()) }
}
#[inline]
pub unsafe fn FBadColumnSet(lpptacols: *mut SPropTagArray) -> u32 {
    windows_link::link!("mapi32" "system" fn FBadColumnSet(lpptacols : *mut SPropTagArray) -> u32);
    unsafe { FBadColumnSet(lpptacols as _) }
}
#[inline]
pub unsafe fn FBadEntryList(lpentrylist: *mut SBinaryArray) -> windows_core::BOOL {
    windows_link::link!("mapi32" "system" fn FBadEntryList(lpentrylist : *mut SBinaryArray) -> windows_core::BOOL);
    unsafe { FBadEntryList(lpentrylist as _) }
}
#[inline]
pub unsafe fn FBadProp(lpprop: *mut SPropValue) -> u32 {
    windows_link::link!("mapi32" "system" fn FBadProp(lpprop : *mut SPropValue) -> u32);
    unsafe { FBadProp(lpprop as _) }
}
#[inline]
pub unsafe fn FBadPropTag(ulproptag: u32) -> u32 {
    windows_link::link!("mapi32" "system" fn FBadPropTag(ulproptag : u32) -> u32);
    unsafe { FBadPropTag(ulproptag) }
}
#[inline]
pub unsafe fn FBadRestriction(lpres: *mut SRestriction) -> u32 {
    windows_link::link!("mapi32" "system" fn FBadRestriction(lpres : *mut SRestriction) -> u32);
    unsafe { FBadRestriction(lpres as _) }
}
#[inline]
pub unsafe fn FBadRglpNameID(lppnameid: *mut *mut MAPINAMEID, cnames: u32) -> windows_core::BOOL {
    windows_link::link!("mapi32" "system" fn FBadRglpNameID(lppnameid : *mut *mut MAPINAMEID, cnames : u32) -> windows_core::BOOL);
    unsafe { FBadRglpNameID(lppnameid as _, cnames) }
}
#[inline]
pub unsafe fn FBadRglpszW(
    lppszw: *const windows_core::PCWSTR,
    cstrings: u32,
) -> windows_core::BOOL {
    windows_link::link!("mapi32" "system" fn FBadRglpszW(lppszw : *const windows_core::PCWSTR, cstrings : u32) -> windows_core::BOOL);
    unsafe { FBadRglpszW(lppszw, cstrings) }
}
#[inline]
pub unsafe fn FBadRow(lprow: *mut SRow) -> u32 {
    windows_link::link!("mapi32" "system" fn FBadRow(lprow : *mut SRow) -> u32);
    unsafe { FBadRow(lprow as _) }
}
#[inline]
pub unsafe fn FBadRowSet(lprowset: *mut SRowSet) -> windows_core::BOOL {
    windows_link::link!("mapi32" "system" fn FBadRowSet(lprowset : *mut SRowSet) -> windows_core::BOOL);
    unsafe { FBadRowSet(lprowset as _) }
}
#[inline]
pub unsafe fn FBadSortOrderSet(lpsos: *mut SSortOrderSet) -> u32 {
    windows_link::link!("mapi32" "system" fn FBadSortOrderSet(lpsos : *mut SSortOrderSet) -> u32);
    unsafe { FBadSortOrderSet(lpsos as _) }
}
#[inline]
pub unsafe fn FBinFromHex(lpsz: *const i8, lpb: *mut u8) -> windows_core::BOOL {
    windows_link::link!("mapi32" "system" fn FBinFromHex(lpsz : *const i8, lpb : *mut u8) -> windows_core::BOOL);
    unsafe { FBinFromHex(lpsz, lpb as _) }
}
#[inline]
pub unsafe fn FEqualNames(
    lpname1: *mut MAPINAMEID,
    lpname2: *mut MAPINAMEID,
) -> windows_core::BOOL {
    windows_link::link!("mapi32" "system" fn FEqualNames(lpname1 : *mut MAPINAMEID, lpname2 : *mut MAPINAMEID) -> windows_core::BOOL);
    unsafe { FEqualNames(lpname1 as _, lpname2 as _) }
}
#[inline]
pub unsafe fn FPropCompareProp(
    lpspropvalue1: *mut SPropValue,
    ulrelop: u32,
    lpspropvalue2: *mut SPropValue,
) -> windows_core::BOOL {
    windows_link::link!("mapi32" "system" fn FPropCompareProp(lpspropvalue1 : *mut SPropValue, ulrelop : u32, lpspropvalue2 : *mut SPropValue) -> windows_core::BOOL);
    unsafe { FPropCompareProp(lpspropvalue1 as _, ulrelop, lpspropvalue2 as _) }
}
#[inline]
pub unsafe fn FPropContainsProp(
    lpspropvaluedst: *mut SPropValue,
    lpspropvaluesrc: *mut SPropValue,
    ulfuzzylevel: u32,
) -> windows_core::BOOL {
    windows_link::link!("mapi32" "system" fn FPropContainsProp(lpspropvaluedst : *mut SPropValue, lpspropvaluesrc : *mut SPropValue, ulfuzzylevel : u32) -> windows_core::BOOL);
    unsafe { FPropContainsProp(lpspropvaluedst as _, lpspropvaluesrc as _, ulfuzzylevel) }
}
#[inline]
pub unsafe fn FPropExists<P0>(lpmapiprop: P0, ulproptag: u32) -> windows_core::BOOL
where
    P0: windows_core::Param<IMAPIProp>,
{
    windows_link::link!("mapi32" "system" fn FPropExists(lpmapiprop : * mut core::ffi::c_void, ulproptag : u32) -> windows_core::BOOL);
    unsafe { FPropExists(lpmapiprop.param().abi(), ulproptag) }
}
#[inline]
pub unsafe fn FreePadrlist(lpadrlist: *mut ADRLIST) {
    windows_link::link!("mapi32" "system" fn FreePadrlist(lpadrlist : *mut ADRLIST));
    unsafe { FreePadrlist(lpadrlist as _) }
}
#[inline]
pub unsafe fn FreeProws(lprows: *mut SRowSet) {
    windows_link::link!("mapi32" "system" fn FreeProws(lprows : *mut SRowSet));
    unsafe { FreeProws(lprows as _) }
}
#[inline]
pub unsafe fn FtAddFt(
    ftaddend1: windows::Win32::Foundation::FILETIME,
    ftaddend2: windows::Win32::Foundation::FILETIME,
) -> windows::Win32::Foundation::FILETIME {
    windows_link::link!("mapi32" "system" fn FtAddFt(ftaddend1 : windows::Win32::Foundation:: FILETIME, ftaddend2 : windows::Win32::Foundation:: FILETIME) -> windows::Win32::Foundation:: FILETIME);
    unsafe {
        FtAddFt(
            core::mem::transmute(ftaddend1),
            core::mem::transmute(ftaddend2),
        )
    }
}
#[inline]
pub unsafe fn FtMulDw(
    ftmultiplier: u32,
    ftmultiplicand: windows::Win32::Foundation::FILETIME,
) -> windows::Win32::Foundation::FILETIME {
    windows_link::link!("mapi32" "system" fn FtMulDw(ftmultiplier : u32, ftmultiplicand : windows::Win32::Foundation:: FILETIME) -> windows::Win32::Foundation:: FILETIME);
    unsafe { FtMulDw(ftmultiplier, core::mem::transmute(ftmultiplicand)) }
}
#[inline]
pub unsafe fn FtMulDwDw(
    ftmultiplicand: u32,
    ftmultiplier: u32,
) -> windows::Win32::Foundation::FILETIME {
    windows_link::link!("mapi32" "system" fn FtMulDwDw(ftmultiplicand : u32, ftmultiplier : u32) -> windows::Win32::Foundation:: FILETIME);
    unsafe { FtMulDwDw(ftmultiplicand, ftmultiplier) }
}
#[inline]
pub unsafe fn FtNegFt(
    ft: windows::Win32::Foundation::FILETIME,
) -> windows::Win32::Foundation::FILETIME {
    windows_link::link!("mapi32" "system" fn FtNegFt(ft : windows::Win32::Foundation:: FILETIME) -> windows::Win32::Foundation:: FILETIME);
    unsafe { FtNegFt(core::mem::transmute(ft)) }
}
#[inline]
pub unsafe fn FtSubFt(
    ftminuend: windows::Win32::Foundation::FILETIME,
    ftsubtrahend: windows::Win32::Foundation::FILETIME,
) -> windows::Win32::Foundation::FILETIME {
    windows_link::link!("mapi32" "system" fn FtSubFt(ftminuend : windows::Win32::Foundation:: FILETIME, ftsubtrahend : windows::Win32::Foundation:: FILETIME) -> windows::Win32::Foundation:: FILETIME);
    unsafe {
        FtSubFt(
            core::mem::transmute(ftminuend),
            core::mem::transmute(ftsubtrahend),
        )
    }
}
#[inline]
pub unsafe fn FtgRegisterIdleRoutine(
    lpfnidle: PFNIDLE,
    lpvidleparam: *mut core::ffi::c_void,
    priidle: i16,
    csecidle: u32,
    iroidle: u16,
) -> *mut core::ffi::c_void {
    windows_link::link!("mapi32" "system" fn FtgRegisterIdleRoutine(lpfnidle : PFNIDLE, lpvidleparam : *mut core::ffi::c_void, priidle : i16, csecidle : u32, iroidle : u16) -> *mut core::ffi::c_void);
    unsafe { FtgRegisterIdleRoutine(lpfnidle, lpvidleparam as _, priidle, csecidle, iroidle) }
}
#[inline]
pub unsafe fn GetAttribIMsgOnIStg(
    lpobject: *mut core::ffi::c_void,
    lpproptagarray: *mut SPropTagArray,
    lpppropattrarray: *mut *mut SPropAttrArray,
) -> windows_core::Result<()> {
    windows_link::link!("mapi32" "system" fn GetAttribIMsgOnIStg(lpobject : *mut core::ffi::c_void, lpproptagarray : *mut SPropTagArray, lpppropattrarray : *mut *mut SPropAttrArray) -> windows_core::HRESULT);
    unsafe { GetAttribIMsgOnIStg(lpobject as _, lpproptagarray as _, lpppropattrarray as _).ok() }
}
#[inline]
pub unsafe fn HexFromBin(lpb: *mut u8, cb: i32, lpsz: *const i8) {
    windows_link::link!("mapi32" "system" fn HexFromBin(lpb : *mut u8, cb : i32, lpsz : *const i8));
    unsafe { HexFromBin(lpb as _, cb, lpsz) }
}
#[inline]
pub unsafe fn HrAddColumns<P0>(
    lptbl: P0,
    lpproptagcolumnsnew: *mut SPropTagArray,
    lpallocatebuffer: LPALLOCATEBUFFER,
    lpfreebuffer: LPFREEBUFFER,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPITable>,
{
    windows_link::link!("mapi32" "system" fn HrAddColumns(lptbl : * mut core::ffi::c_void, lpproptagcolumnsnew : *mut SPropTagArray, lpallocatebuffer : LPALLOCATEBUFFER, lpfreebuffer : LPFREEBUFFER) -> windows_core::HRESULT);
    unsafe {
        HrAddColumns(
            lptbl.param().abi(),
            lpproptagcolumnsnew as _,
            lpallocatebuffer,
            lpfreebuffer,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrAddColumnsEx<P0>(
    lptbl: P0,
    lpproptagcolumnsnew: *mut SPropTagArray,
    lpallocatebuffer: LPALLOCATEBUFFER,
    lpfreebuffer: LPFREEBUFFER,
    lpfnfiltercolumns: isize,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPITable>,
{
    windows_link::link!("mapi32" "system" fn HrAddColumnsEx(lptbl : * mut core::ffi::c_void, lpproptagcolumnsnew : *mut SPropTagArray, lpallocatebuffer : LPALLOCATEBUFFER, lpfreebuffer : LPFREEBUFFER, lpfnfiltercolumns : isize) -> windows_core::HRESULT);
    unsafe {
        HrAddColumnsEx(
            lptbl.param().abi(),
            lpproptagcolumnsnew as _,
            lpallocatebuffer,
            lpfreebuffer,
            lpfnfiltercolumns,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrAllocAdviseSink(
    lpfncallback: LPNOTIFCALLBACK,
    lpvcontext: *mut core::ffi::c_void,
    lppadvisesink: *mut Option<IMAPIAdviseSink>,
) -> windows_core::Result<()> {
    windows_link::link!("mapi32" "system" fn HrAllocAdviseSink(lpfncallback : LPNOTIFCALLBACK, lpvcontext : *mut core::ffi::c_void, lppadvisesink : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        HrAllocAdviseSink(
            lpfncallback,
            lpvcontext as _,
            core::mem::transmute(lppadvisesink),
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrCompareABEntryIDsWithExchangeContext<P0, P2>(
    pmsess: P0,
    pemsmdbuid: *const MAPIUID,
    paddrbook: P2,
    cbentryid1: u32,
    lpentryid1: *mut ENTRYID,
    cbentryid2: u32,
    lpentryid2: *mut ENTRYID,
    ulflags: u32,
    lpulresult: *mut u32,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPISession>,
    P2: windows_core::Param<IAddrBook>,
{
    windows_link::link!("olmapi32" "system" fn HrCompareABEntryIDsWithExchangeContext(pmsess : * mut core::ffi::c_void, pemsmdbuid : *const MAPIUID, paddrbook : * mut core::ffi::c_void, cbentryid1 : u32, lpentryid1 : *mut ENTRYID, cbentryid2 : u32, lpentryid2 : *mut ENTRYID, ulflags : u32, lpulresult : *mut u32) -> windows_core::HRESULT);
    unsafe {
        HrCompareABEntryIDsWithExchangeContext(
            pmsess.param().abi(),
            pemsmdbuid,
            paddrbook.param().abi(),
            cbentryid1,
            lpentryid1 as _,
            cbentryid2,
            lpentryid2 as _,
            ulflags,
            lpulresult as _,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrComposeEID<P0>(
    lpsession: P0,
    cbstorerecordkey: u32,
    lpstorerecordkey: *mut u8,
    cbmsgentryid: u32,
    lpmsgentryid: *mut ENTRYID,
    lpcbeid: *mut u32,
    lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPISession>,
{
    windows_link::link!("mapi32" "system" fn HrComposeEID(lpsession : * mut core::ffi::c_void, cbstorerecordkey : u32, lpstorerecordkey : *mut u8, cbmsgentryid : u32, lpmsgentryid : *mut ENTRYID, lpcbeid : *mut u32, lppentryid : *mut *mut ENTRYID) -> windows_core::HRESULT);
    unsafe {
        HrComposeEID(
            lpsession.param().abi(),
            cbstorerecordkey,
            lpstorerecordkey as _,
            cbmsgentryid,
            lpmsgentryid as _,
            lpcbeid as _,
            lppentryid as _,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrComposeMsgID<P0>(
    lpsession: P0,
    cbstoresearchkey: u32,
    pstoresearchkey: *mut u8,
    cbmsgentryid: u32,
    lpmsgentryid: *mut ENTRYID,
    lpszmsgid: *const *const i8,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPISession>,
{
    windows_link::link!("mapi32" "system" fn HrComposeMsgID(lpsession : * mut core::ffi::c_void, cbstoresearchkey : u32, pstoresearchkey : *mut u8, cbmsgentryid : u32, lpmsgentryid : *mut ENTRYID, lpszmsgid : *const *const i8) -> windows_core::HRESULT);
    unsafe {
        HrComposeMsgID(
            lpsession.param().abi(),
            cbstoresearchkey,
            pstoresearchkey as _,
            cbmsgentryid,
            lpmsgentryid as _,
            lpszmsgid,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrDecomposeEID<P0>(
    lpsession: P0,
    cbentryid: u32,
    lpentryid: *mut ENTRYID,
    lpcbstoreentryid: *mut u32,
    lppstoreentryid: *mut *mut ENTRYID,
    lpcbmsgentryid: *mut u32,
    lppmsgentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPISession>,
{
    windows_link::link!("mapi32" "system" fn HrDecomposeEID(lpsession : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpcbstoreentryid : *mut u32, lppstoreentryid : *mut *mut ENTRYID, lpcbmsgentryid : *mut u32, lppmsgentryid : *mut *mut ENTRYID) -> windows_core::HRESULT);
    unsafe {
        HrDecomposeEID(
            lpsession.param().abi(),
            cbentryid,
            lpentryid as _,
            lpcbstoreentryid as _,
            lppstoreentryid as _,
            lpcbmsgentryid as _,
            lppmsgentryid as _,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrDecomposeMsgID<P0>(
    lpsession: P0,
    lpszmsgid: *const i8,
    lpcbstoreentryid: *mut u32,
    lppstoreentryid: *mut *mut ENTRYID,
    lppcbmsgentryid: *mut u32,
    lppmsgentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPISession>,
{
    windows_link::link!("mapi32" "system" fn HrDecomposeMsgID(lpsession : * mut core::ffi::c_void, lpszmsgid : *const i8, lpcbstoreentryid : *mut u32, lppstoreentryid : *mut *mut ENTRYID, lppcbmsgentryid : *mut u32, lppmsgentryid : *mut *mut ENTRYID) -> windows_core::HRESULT);
    unsafe {
        HrDecomposeMsgID(
            lpsession.param().abi(),
            lpszmsgid,
            lpcbstoreentryid as _,
            lppstoreentryid as _,
            lppcbmsgentryid as _,
            lppmsgentryid as _,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrDispatchNotifications(ulflags: u32) -> windows_core::Result<()> {
    windows_link::link!("mapi32" "system" fn HrDispatchNotifications(ulflags : u32) -> windows_core::HRESULT);
    unsafe { HrDispatchNotifications(ulflags).ok() }
}
#[inline]
pub unsafe fn HrDoABDetailsWithExchangeContext<P0, P2>(
    pmsess: P0,
    pemsmdbuid: *const MAPIUID,
    paddrbook: P2,
    lpuluiparam: *mut usize,
    lpfndismiss: LPFNDISMISS,
    lpvdismisscontext: *mut core::ffi::c_void,
    cbentryid: u32,
    lpentryid: *mut ENTRYID,
    lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
    lpvbuttoncontext: *mut core::ffi::c_void,
    lpszbuttontext: *mut i8,
    ulflags: u32,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPISession>,
    P2: windows_core::Param<IAddrBook>,
{
    windows_link::link!("olmapi32" "system" fn HrDoABDetailsWithExchangeContext(pmsess : * mut core::ffi::c_void, pemsmdbuid : *const MAPIUID, paddrbook : * mut core::ffi::c_void, lpuluiparam : *mut usize, lpfndismiss : LPFNDISMISS, lpvdismisscontext : *mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpfbuttoncallback : windows::Win32::System::AddressBook:: LPFNBUTTON, lpvbuttoncontext : *mut core::ffi::c_void, lpszbuttontext : *mut i8, ulflags : u32) -> windows_core::HRESULT);
    unsafe {
        HrDoABDetailsWithExchangeContext(
            pmsess.param().abi(),
            pemsmdbuid,
            paddrbook.param().abi(),
            lpuluiparam as _,
            lpfndismiss,
            lpvdismisscontext as _,
            cbentryid,
            lpentryid as _,
            lpfbuttoncallback,
            lpvbuttoncontext as _,
            lpszbuttontext as _,
            ulflags,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrDoABDetailsWithProviderUID<P1>(
    pemsabpuid: *const MAPIUID,
    paddrbook: P1,
    lpuluiparam: *mut usize,
    lpfndismiss: LPFNDISMISS,
    lpvdismisscontext: *mut core::ffi::c_void,
    cbentryid: u32,
    lpentryid: *mut ENTRYID,
    lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
    lpvbuttoncontext: *mut core::ffi::c_void,
    lpszbuttontext: *mut i8,
    ulflags: u32,
) -> windows_core::Result<()>
where
    P1: windows_core::Param<IAddrBook>,
{
    windows_link::link!("olmapi32" "system" fn HrDoABDetailsWithProviderUID(pemsabpuid : *const MAPIUID, paddrbook : * mut core::ffi::c_void, lpuluiparam : *mut usize, lpfndismiss : LPFNDISMISS, lpvdismisscontext : *mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpfbuttoncallback : windows::Win32::System::AddressBook:: LPFNBUTTON, lpvbuttoncontext : *mut core::ffi::c_void, lpszbuttontext : *mut i8, ulflags : u32) -> windows_core::HRESULT);
    unsafe {
        HrDoABDetailsWithProviderUID(
            pemsabpuid,
            paddrbook.param().abi(),
            lpuluiparam as _,
            lpfndismiss,
            lpvdismisscontext as _,
            cbentryid,
            lpentryid as _,
            lpfbuttoncallback,
            lpvbuttoncontext as _,
            lpszbuttontext as _,
            ulflags,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrEntryIDFromSz(
    lpsz: *const i8,
    lpcb: *mut u32,
    lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
    windows_link::link!("mapi32" "system" fn HrEntryIDFromSz(lpsz : *const i8, lpcb : *mut u32, lppentryid : *mut *mut ENTRYID) -> windows_core::HRESULT);
    unsafe { HrEntryIDFromSz(lpsz, lpcb as _, lppentryid as _).ok() }
}
#[inline]
pub unsafe fn HrGetGALFromEmsmdbUID<P0, P1>(
    psess: P0,
    lpadrbook: P1,
    pemsmdbuid: *const MAPIUID,
    lpcbeid: *mut u32,
    lppeid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPISession>,
    P1: windows_core::Param<IAddrBook>,
{
    windows_link::link!("olmapi32" "system" fn HrGetGALFromEmsmdbUID(psess : * mut core::ffi::c_void, lpadrbook : * mut core::ffi::c_void, pemsmdbuid : *const MAPIUID, lpcbeid : *mut u32, lppeid : *mut *mut ENTRYID) -> windows_core::HRESULT);
    unsafe {
        HrGetGALFromEmsmdbUID(
            psess.param().abi(),
            lpadrbook.param().abi(),
            pemsmdbuid,
            lpcbeid as _,
            lppeid as _,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrGetOneProp<P0>(
    lpmapiprop: P0,
    ulproptag: u32,
    lppprop: *mut *mut SPropValue,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPIProp>,
{
    windows_link::link!("mapi32" "system" fn HrGetOneProp(lpmapiprop : * mut core::ffi::c_void, ulproptag : u32, lppprop : *mut *mut SPropValue) -> windows_core::HRESULT);
    unsafe { HrGetOneProp(lpmapiprop.param().abi(), ulproptag, lppprop as _).ok() }
}
#[inline]
pub unsafe fn HrIStorageFromStream<P0>(
    lpunkin: P0,
    lpinterface: *mut windows_core::GUID,
    ulflags: u32,
    lppstorageout: *mut Option<windows::Win32::System::Com::StructuredStorage::IStorage>,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<windows_core::IUnknown>,
{
    windows_link::link!("mapi32" "system" fn HrIStorageFromStream(lpunkin : * mut core::ffi::c_void, lpinterface : *mut windows_core::GUID, ulflags : u32, lppstorageout : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        HrIStorageFromStream(
            lpunkin.param().abi(),
            lpinterface as _,
            ulflags,
            core::mem::transmute(lppstorageout),
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrOpenABEntryUsingDefaultContext<P0, P1>(
    pmsess: P0,
    paddrbook: P1,
    cbentryid: u32,
    lpentryid: *mut ENTRYID,
    lpinterface: *mut windows_core::GUID,
    ulflags: u32,
    lpulobjtype: *mut u32,
    lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPISession>,
    P1: windows_core::Param<IAddrBook>,
{
    windows_link::link!("olmapi32" "system" fn HrOpenABEntryUsingDefaultContext(pmsess : * mut core::ffi::c_void, paddrbook : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpinterface : *mut windows_core::GUID, ulflags : u32, lpulobjtype : *mut u32, lppunk : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        HrOpenABEntryUsingDefaultContext(
            pmsess.param().abi(),
            paddrbook.param().abi(),
            cbentryid,
            lpentryid as _,
            lpinterface as _,
            ulflags,
            lpulobjtype as _,
            core::mem::transmute(lppunk),
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrOpenABEntryWithExchangeContext<P0, P2>(
    pmsess: P0,
    pemsmdbuid: *const MAPIUID,
    paddrbook: P2,
    cbentryid: u32,
    lpentryid: *mut ENTRYID,
    lpinterface: *mut windows_core::GUID,
    ulflags: u32,
    lpulobjtype: *mut u32,
    lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPISession>,
    P2: windows_core::Param<IAddrBook>,
{
    windows_link::link!("olmapi32" "system" fn HrOpenABEntryWithExchangeContext(pmsess : * mut core::ffi::c_void, pemsmdbuid : *const MAPIUID, paddrbook : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpinterface : *mut windows_core::GUID, ulflags : u32, lpulobjtype : *mut u32, lppunk : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        HrOpenABEntryWithExchangeContext(
            pmsess.param().abi(),
            pemsmdbuid,
            paddrbook.param().abi(),
            cbentryid,
            lpentryid as _,
            lpinterface as _,
            ulflags,
            lpulobjtype as _,
            core::mem::transmute(lppunk),
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrOpenABEntryWithProviderUID<P1>(
    pemsabpuid: *const MAPIUID,
    paddrbook: P1,
    cbentryid: u32,
    lpentryid: *mut ENTRYID,
    lpinterface: *mut windows_core::GUID,
    ulflags: u32,
    lpulobjtype: *mut u32,
    lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()>
where
    P1: windows_core::Param<IAddrBook>,
{
    windows_link::link!("olmapi32" "system" fn HrOpenABEntryWithProviderUID(pemsabpuid : *const MAPIUID, paddrbook : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpinterface : *mut windows_core::GUID, ulflags : u32, lpulobjtype : *mut u32, lppunk : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        HrOpenABEntryWithProviderUID(
            pemsabpuid,
            paddrbook.param().abi(),
            cbentryid,
            lpentryid as _,
            lpinterface as _,
            ulflags,
            lpulobjtype as _,
            core::mem::transmute(lppunk),
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrOpenABEntryWithProviderUIDSupport<P1>(
    pemsabpuid: *const MAPIUID,
    lpsup: P1,
    cbentryid: u32,
    lpentryid: *mut ENTRYID,
    lpinterface: *mut windows_core::GUID,
    ulflags: u32,
    lpulobjtype: *mut u32,
    lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()>
where
    P1: windows_core::Param<IMAPISupport>,
{
    windows_link::link!("olmapi32" "system" fn HrOpenABEntryWithProviderUIDSupport(pemsabpuid : *const MAPIUID, lpsup : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpinterface : *mut windows_core::GUID, ulflags : u32, lpulobjtype : *mut u32, lppunk : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        HrOpenABEntryWithProviderUIDSupport(
            pemsabpuid,
            lpsup.param().abi(),
            cbentryid,
            lpentryid as _,
            lpinterface as _,
            ulflags,
            lpulobjtype as _,
            core::mem::transmute(lppunk),
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrOpenABEntryWithResolvedRow<P1>(
    prwresolved: *mut SRow,
    paddrbook: P1,
    cbentryid: u32,
    lpentryid: *mut ENTRYID,
    lpinterface: *mut windows_core::GUID,
    ulflags: u32,
    lpulobjtype: *mut u32,
    lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()>
where
    P1: windows_core::Param<IAddrBook>,
{
    windows_link::link!("olmapi32" "system" fn HrOpenABEntryWithResolvedRow(prwresolved : *mut SRow, paddrbook : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpinterface : *mut windows_core::GUID, ulflags : u32, lpulobjtype : *mut u32, lppunk : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        HrOpenABEntryWithResolvedRow(
            prwresolved as _,
            paddrbook.param().abi(),
            cbentryid,
            lpentryid as _,
            lpinterface as _,
            ulflags,
            lpulobjtype as _,
            core::mem::transmute(lppunk),
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrOpenABEntryWithSupport<P0>(
    lpsup: P0,
    cbentryid: u32,
    lpentryid: *mut ENTRYID,
    lpinterface: *mut windows_core::GUID,
    ulflags: u32,
    lpulobjtype: *mut u32,
    lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPISupport>,
{
    windows_link::link!("olmapi32" "system" fn HrOpenABEntryWithSupport(lpsup : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpinterface : *mut windows_core::GUID, ulflags : u32, lpulobjtype : *mut u32, lppunk : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        HrOpenABEntryWithSupport(
            lpsup.param().abi(),
            cbentryid,
            lpentryid as _,
            lpinterface as _,
            ulflags,
            lpulobjtype as _,
            core::mem::transmute(lppunk),
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrQueryAllRows<P0>(
    lptable: P0,
    lpproptags: *mut SPropTagArray,
    lprestriction: *mut SRestriction,
    lpsortorderset: *mut SSortOrderSet,
    crowsmax: i32,
    lpprows: *mut *mut SRowSet,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPITable>,
{
    windows_link::link!("mapi32" "system" fn HrQueryAllRows(lptable : * mut core::ffi::c_void, lpproptags : *mut SPropTagArray, lprestriction : *mut SRestriction, lpsortorderset : *mut SSortOrderSet, crowsmax : i32, lpprows : *mut *mut SRowSet) -> windows_core::HRESULT);
    unsafe {
        HrQueryAllRows(
            lptable.param().abi(),
            lpproptags as _,
            lprestriction as _,
            lpsortorderset as _,
            crowsmax,
            lpprows as _,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrSetOneProp<P0>(lpmapiprop: P0, lpprop: *mut SPropValue) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMAPIProp>,
{
    windows_link::link!("mapi32" "system" fn HrSetOneProp(lpmapiprop : * mut core::ffi::c_void, lpprop : *mut SPropValue) -> windows_core::HRESULT);
    unsafe { HrSetOneProp(lpmapiprop.param().abi(), lpprop as _).ok() }
}
#[inline]
pub unsafe fn HrSzFromEntryID(
    cb: u32,
    lpentryid: *mut ENTRYID,
    lpsz: *const *const i8,
) -> windows_core::Result<()> {
    windows_link::link!("mapi32" "system" fn HrSzFromEntryID(cb : u32, lpentryid : *mut ENTRYID, lpsz : *const *const i8) -> windows_core::HRESULT);
    unsafe { HrSzFromEntryID(cb, lpentryid as _, lpsz).ok() }
}
#[inline]
pub unsafe fn HrThisThreadAdviseSink<P0>(lpadvisesink: P0) -> windows_core::Result<IMAPIAdviseSink>
where
    P0: windows_core::Param<IMAPIAdviseSink>,
{
    windows_link::link!("mapi32" "system" fn HrThisThreadAdviseSink(lpadvisesink : * mut core::ffi::c_void, lppadvisesink : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        let mut result__ = core::mem::zeroed();
        HrThisThreadAdviseSink(lpadvisesink.param().abi(), &mut result__)
            .and_then(|| windows_core::Type::from_abi(result__))
    }
}
#[inline]
pub unsafe fn HrValidateIPMSubtree<P0>(
    lpmdb: P0,
    ulflags: u32,
    lpcvalues: *mut u32,
    lppvalues: *mut *mut SPropValue,
    lpperr: *mut *mut MAPIERROR,
) -> windows_core::Result<()>
where
    P0: windows_core::Param<IMsgStore>,
{
    windows_link::link!("mapi32" "system" fn HrValidateIPMSubtree(lpmdb : * mut core::ffi::c_void, ulflags : u32, lpcvalues : *mut u32, lppvalues : *mut *mut SPropValue, lpperr : *mut *mut MAPIERROR) -> windows_core::HRESULT);
    unsafe {
        HrValidateIPMSubtree(
            lpmdb.param().abi(),
            ulflags,
            lpcvalues as _,
            lppvalues as _,
            lpperr as _,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn HrValidateParameters(
    emethod: METHODS,
    ppfirstarg: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()> {
    windows_link::link!("olmapi32" "system" fn HrValidateParameters(emethod : METHODS, ppfirstarg : *mut *mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe { HrValidateParameters(emethod, ppfirstarg as _).ok() }
}
#[inline]
pub unsafe fn IsBadBoundedStringPtr(
    lpsz: *const core::ffi::c_void,
    cchmax: u32,
) -> windows_core::BOOL {
    windows_link::link!("mapi32" "system" fn IsBadBoundedStringPtr(lpsz : *const core::ffi::c_void, cchmax : u32) -> windows_core::BOOL);
    unsafe { IsBadBoundedStringPtr(lpsz, cchmax) }
}
#[inline]
pub unsafe fn LPropCompareProp(
    lpspropvaluea: *mut SPropValue,
    lpspropvalueb: *mut SPropValue,
) -> i32 {
    windows_link::link!("mapi32" "system" fn LPropCompareProp(lpspropvaluea : *mut SPropValue, lpspropvalueb : *mut SPropValue) -> i32);
    unsafe { LPropCompareProp(lpspropvaluea as _, lpspropvalueb as _) }
}
#[inline]
pub unsafe fn LpValFindProp(
    ulproptag: u32,
    cvalues: u32,
    lpproparray: *mut SPropValue,
) -> *mut SPropValue {
    windows_link::link!("mapi32" "system" fn LpValFindProp(ulproptag : u32, cvalues : u32, lpproparray : *mut SPropValue) -> *mut SPropValue);
    unsafe { LpValFindProp(ulproptag, cvalues, lpproparray as _) }
}
#[inline]
pub unsafe fn MAPIAddress<P2, P4>(
    param0: usize,
    param1: usize,
    param2: P2,
    param3: u32,
    param4: P4,
    param5: u32,
    param6: *mut MapiRecipDesc,
    param7: u32,
    param8: u32,
    param9: *mut u32,
    param10: *mut *mut MapiRecipDesc,
) -> u32
where
    P2: windows_core::Param<windows_core::PCSTR>,
    P4: windows_core::Param<windows_core::PCSTR>,
{
    windows_link::link!("mapi32" "system" fn MAPIAddress(param0 : usize, param1 : usize, param2 : windows_core::PCSTR, param3 : u32, param4 : windows_core::PCSTR, param5 : u32, param6 : *mut MapiRecipDesc, param7 : u32, param8 : u32, param9 : *mut u32, param10 : *mut *mut MapiRecipDesc) -> u32);
    unsafe {
        MAPIAddress(
            param0,
            param1,
            param2.param().abi(),
            param3,
            param4.param().abi(),
            param5,
            param6 as _,
            param7,
            param8,
            param9 as _,
            param10 as _,
        )
    }
}
#[inline]
pub unsafe fn MAPIAdminProfiles(param0: u32) -> windows_core::Result<IProfAdmin> {
    windows_link::link!("mapi32" "system" fn MAPIAdminProfiles(param0 : u32, param1 : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        let mut result__ = core::mem::zeroed();
        MAPIAdminProfiles(param0, &mut result__).and_then(|| windows_core::Type::from_abi(result__))
    }
}
#[inline]
pub unsafe fn MAPIAllocateBuffer(param0: u32, param1: *mut *mut core::ffi::c_void) -> i32 {
    windows_link::link!("mapi32" "system" fn MAPIAllocateBuffer(param0 : u32, param1 : *mut *mut core::ffi::c_void) -> i32);
    unsafe { MAPIAllocateBuffer(param0, param1 as _) }
}
#[inline]
pub unsafe fn MAPIAllocateMore(
    param0: u32,
    param1: *mut core::ffi::c_void,
    param2: *mut *mut core::ffi::c_void,
) -> i32 {
    windows_link::link!("mapi32" "system" fn MAPIAllocateMore(param0 : u32, param1 : *mut core::ffi::c_void, param2 : *mut *mut core::ffi::c_void) -> i32);
    unsafe { MAPIAllocateMore(param0, param1 as _, param2 as _) }
}
#[inline]
pub unsafe fn MAPIDeinitIdle() {
    windows_link::link!("mapi32" "system" fn MAPIDeinitIdle());
    unsafe { MAPIDeinitIdle() }
}
#[inline]
pub unsafe fn MAPIDeleteMail<P2>(
    param0: usize,
    param1: usize,
    param2: P2,
    param3: u32,
    param4: u32,
) -> u32
where
    P2: windows_core::Param<windows_core::PCSTR>,
{
    windows_link::link!("mapi32" "system" fn MAPIDeleteMail(param0 : usize, param1 : usize, param2 : windows_core::PCSTR, param3 : u32, param4 : u32) -> u32);
    unsafe { MAPIDeleteMail(param0, param1, param2.param().abi(), param3, param4) }
}
#[inline]
pub unsafe fn MAPIDetails(
    param0: usize,
    param1: usize,
    param2: *mut MapiRecipDesc,
    param3: u32,
    param4: u32,
) -> u32 {
    windows_link::link!("mapi32" "system" fn MAPIDetails(param0 : usize, param1 : usize, param2 : *mut MapiRecipDesc, param3 : u32, param4 : u32) -> u32);
    unsafe { MAPIDetails(param0, param1, param2 as _, param3, param4) }
}
#[inline]
pub unsafe fn MAPIFindNext<P2, P3, P6>(
    param0: usize,
    param1: usize,
    param2: P2,
    param3: P3,
    param4: u32,
    param5: u32,
    param6: P6,
) -> u32
where
    P2: windows_core::Param<windows_core::PCSTR>,
    P3: windows_core::Param<windows_core::PCSTR>,
    P6: windows_core::Param<windows_core::PCSTR>,
{
    windows_link::link!("mapi32" "system" fn MAPIFindNext(param0 : usize, param1 : usize, param2 : windows_core::PCSTR, param3 : windows_core::PCSTR, param4 : u32, param5 : u32, param6 : windows_core::PCSTR) -> u32);
    unsafe {
        MAPIFindNext(
            param0,
            param1,
            param2.param().abi(),
            param3.param().abi(),
            param4,
            param5,
            param6.param().abi(),
        )
    }
}
#[inline]
pub unsafe fn MAPIFreeBuffer(param0: *mut core::ffi::c_void) -> u32 {
    windows_link::link!("mapi32" "system" fn MAPIFreeBuffer(param0 : *mut core::ffi::c_void) -> u32);
    unsafe { MAPIFreeBuffer(param0 as _) }
}
#[inline]
pub unsafe fn MAPIGetDefaultMalloc() -> Option<windows::Win32::System::Com::IMalloc> {
    windows_link::link!("mapi32" "system" fn MAPIGetDefaultMalloc() -> Option < windows::Win32::System::Com:: IMalloc >);
    unsafe { MAPIGetDefaultMalloc() }
}
#[inline]
pub unsafe fn MAPIInitIdle(lpvreserved: *mut core::ffi::c_void) -> i32 {
    windows_link::link!("mapi32" "system" fn MAPIInitIdle(lpvreserved : *mut core::ffi::c_void) -> i32);
    unsafe { MAPIInitIdle(lpvreserved as _) }
}
#[inline]
pub unsafe fn MAPIInitialize(param0: *mut core::ffi::c_void) -> windows_core::Result<()> {
    windows_link::link!("mapi32" "system" fn MAPIInitialize(param0 : *mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe { MAPIInitialize(param0 as _).ok() }
}
#[inline]
pub unsafe fn MAPILogoff(param0: usize, param1: usize, param2: u32, param3: u32) -> u32 {
    windows_link::link!("mapi32" "system" fn MAPILogoff(param0 : usize, param1 : usize, param2 : u32, param3 : u32) -> u32);
    unsafe { MAPILogoff(param0, param1, param2, param3) }
}
#[inline]
pub unsafe fn MAPILogon<P1, P2>(
    param0: usize,
    param1: P1,
    param2: P2,
    param3: u32,
    param4: u32,
    param5: *mut usize,
) -> u32
where
    P1: windows_core::Param<windows_core::PCSTR>,
    P2: windows_core::Param<windows_core::PCSTR>,
{
    windows_link::link!("mapi32" "system" fn MAPILogon(param0 : usize, param1 : windows_core::PCSTR, param2 : windows_core::PCSTR, param3 : u32, param4 : u32, param5 : *mut usize) -> u32);
    unsafe {
        MAPILogon(
            param0,
            param1.param().abi(),
            param2.param().abi(),
            param3,
            param4,
            param5 as _,
        )
    }
}
#[inline]
pub unsafe fn MAPILogonEx(
    param0: usize,
    param1: *mut i8,
    param2: *mut i8,
    param3: u32,
    param4: *mut Option<IMAPISession>,
) -> windows_core::Result<()> {
    windows_link::link!("mapi32" "system" fn MAPILogonEx(param0 : usize, param1 : *mut i8, param2 : *mut i8, param3 : u32, param4 : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        MAPILogonEx(
            param0,
            param1 as _,
            param2 as _,
            param3,
            core::mem::transmute(param4),
        )
        .ok()
    }
}
#[inline]
pub unsafe fn MAPIOpenFormMgr<P0>(psession: P0) -> windows_core::Result<IMAPIFormMgr>
where
    P0: windows_core::Param<IMAPISession>,
{
    windows_link::link!("mapi32" "system" fn MAPIOpenFormMgr(psession : * mut core::ffi::c_void, ppmgr : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        let mut result__ = core::mem::zeroed();
        MAPIOpenFormMgr(psession.param().abi(), &mut result__)
            .and_then(|| windows_core::Type::from_abi(result__))
    }
}
#[inline]
pub unsafe fn MAPIOpenLocalFormContainer() -> windows_core::Result<IMAPIFormContainer> {
    windows_link::link!("mapi32" "system" fn MAPIOpenLocalFormContainer(ppfcnt : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        let mut result__ = core::mem::zeroed();
        MAPIOpenLocalFormContainer(&mut result__)
            .and_then(|| windows_core::Type::from_abi(result__))
    }
}
#[inline]
pub unsafe fn MAPIReadMail<P2>(
    param0: usize,
    param1: usize,
    param2: P2,
    param3: u32,
    param4: u32,
    param5: *mut *mut MapiMessage,
) -> u32
where
    P2: windows_core::Param<windows_core::PCSTR>,
{
    windows_link::link!("mapi32" "system" fn MAPIReadMail(param0 : usize, param1 : usize, param2 : windows_core::PCSTR, param3 : u32, param4 : u32, param5 : *mut *mut MapiMessage) -> u32);
    unsafe {
        MAPIReadMail(
            param0,
            param1,
            param2.param().abi(),
            param3,
            param4,
            param5 as _,
        )
    }
}
#[inline]
pub unsafe fn MAPIResolveName<P2>(
    param0: usize,
    param1: usize,
    param2: P2,
    param3: u32,
    param4: u32,
    param5: *mut *mut MapiRecipDesc,
) -> u32
where
    P2: windows_core::Param<windows_core::PCSTR>,
{
    windows_link::link!("mapi32" "system" fn MAPIResolveName(param0 : usize, param1 : usize, param2 : windows_core::PCSTR, param3 : u32, param4 : u32, param5 : *mut *mut MapiRecipDesc) -> u32);
    unsafe {
        MAPIResolveName(
            param0,
            param1,
            param2.param().abi(),
            param3,
            param4,
            param5 as _,
        )
    }
}
#[inline]
pub unsafe fn MAPISaveMail<P5>(
    param0: usize,
    param1: usize,
    param2: *mut MapiMessage,
    param3: u32,
    param4: u32,
    param5: P5,
) -> u32
where
    P5: windows_core::Param<windows_core::PCSTR>,
{
    windows_link::link!("mapi32" "system" fn MAPISaveMail(param0 : usize, param1 : usize, param2 : *mut MapiMessage, param3 : u32, param4 : u32, param5 : windows_core::PCSTR) -> u32);
    unsafe {
        MAPISaveMail(
            param0,
            param1,
            param2 as _,
            param3,
            param4,
            param5.param().abi(),
        )
    }
}
#[inline]
pub unsafe fn MAPISendDocuments<P1, P2, P3>(
    param0: usize,
    param1: P1,
    param2: P2,
    param3: P3,
    param4: u32,
) -> u32
where
    P1: windows_core::Param<windows_core::PCSTR>,
    P2: windows_core::Param<windows_core::PCSTR>,
    P3: windows_core::Param<windows_core::PCSTR>,
{
    windows_link::link!("mapi32" "system" fn MAPISendDocuments(param0 : usize, param1 : windows_core::PCSTR, param2 : windows_core::PCSTR, param3 : windows_core::PCSTR, param4 : u32) -> u32);
    unsafe {
        MAPISendDocuments(
            param0,
            param1.param().abi(),
            param2.param().abi(),
            param3.param().abi(),
            param4,
        )
    }
}
#[inline]
pub unsafe fn MAPISendMail(
    param0: usize,
    param1: usize,
    param2: *mut MapiMessage,
    param3: u32,
    param4: u32,
) -> u32 {
    windows_link::link!("mapi32" "system" fn MAPISendMail(param0 : usize, param1 : usize, param2 : *mut MapiMessage, param3 : u32, param4 : u32) -> u32);
    unsafe { MAPISendMail(param0, param1, param2 as _, param3, param4) }
}
#[inline]
pub unsafe fn MAPIUninitialize() {
    windows_link::link!("mapi32" "system" fn MAPIUninitialize());
    unsafe { MAPIUninitialize() }
}
#[inline]
pub unsafe fn MNLS_CompareStringW<P2, P4>(
    locale: u32,
    dwcmpflags: u32,
    lpstring1: P2,
    cchcount1: i32,
    lpstring2: P4,
    cchcount2: i32,
) -> i32
where
    P2: windows_core::Param<windows_core::PCWSTR>,
    P4: windows_core::Param<windows_core::PCWSTR>,
{
    windows_link::link!("mapi32" "system" fn MNLS_CompareStringW(locale : u32, dwcmpflags : u32, lpstring1 : windows_core::PCWSTR, cchcount1 : i32, lpstring2 : windows_core::PCWSTR, cchcount2 : i32) -> i32);
    unsafe {
        MNLS_CompareStringW(
            locale,
            dwcmpflags,
            lpstring1.param().abi(),
            cchcount1,
            lpstring2.param().abi(),
            cchcount2,
        )
    }
}
#[inline]
pub unsafe fn MNLS_IsBadStringPtrW<P0>(lpsz: P0, ucchmax: u32) -> windows_core::BOOL
where
    P0: windows_core::Param<windows_core::PCWSTR>,
{
    windows_link::link!("mapi32" "system" fn MNLS_IsBadStringPtrW(lpsz : windows_core::PCWSTR, ucchmax : u32) -> windows_core::BOOL);
    unsafe { MNLS_IsBadStringPtrW(lpsz.param().abi(), ucchmax) }
}
#[inline]
pub unsafe fn MNLS_MultiByteToWideChar<P2, P4>(
    ucodepage: u32,
    dwflags: u32,
    lpmultibytestr: P2,
    cchmultibyte: i32,
    lpwidecharstr: P4,
    cchwidechar: i32,
) -> i32
where
    P2: windows_core::Param<windows_core::PCSTR>,
    P4: windows_core::Param<windows_core::PCWSTR>,
{
    windows_link::link!("mapi32" "system" fn MNLS_MultiByteToWideChar(ucodepage : u32, dwflags : u32, lpmultibytestr : windows_core::PCSTR, cchmultibyte : i32, lpwidecharstr : windows_core::PCWSTR, cchwidechar : i32) -> i32);
    unsafe {
        MNLS_MultiByteToWideChar(
            ucodepage,
            dwflags,
            lpmultibytestr.param().abi(),
            cchmultibyte,
            lpwidecharstr.param().abi(),
            cchwidechar,
        )
    }
}
#[inline]
pub unsafe fn MNLS_WideCharToMultiByte<P2, P4, P6>(
    ucodepage: u32,
    dwflags: u32,
    lpwidecharstr: P2,
    cchwidechar: i32,
    lpmultibytestr: P4,
    cchmultibyte: i32,
    lpdefaultchar: P6,
    lpfuseddefaultchar: *mut windows_core::BOOL,
) -> i32
where
    P2: windows_core::Param<windows_core::PCWSTR>,
    P4: windows_core::Param<windows_core::PCSTR>,
    P6: windows_core::Param<windows_core::PCSTR>,
{
    windows_link::link!("mapi32" "system" fn MNLS_WideCharToMultiByte(ucodepage : u32, dwflags : u32, lpwidecharstr : windows_core::PCWSTR, cchwidechar : i32, lpmultibytestr : windows_core::PCSTR, cchmultibyte : i32, lpdefaultchar : windows_core::PCSTR, lpfuseddefaultchar : *mut windows_core::BOOL) -> i32);
    unsafe {
        MNLS_WideCharToMultiByte(
            ucodepage,
            dwflags,
            lpwidecharstr.param().abi(),
            cchwidechar,
            lpmultibytestr.param().abi(),
            cchmultibyte,
            lpdefaultchar.param().abi(),
            lpfuseddefaultchar as _,
        )
    }
}
#[inline]
pub unsafe fn MNLS_lstrcmpW<P0, P1>(lpstring1: P0, lpstring2: P1) -> i32
where
    P0: windows_core::Param<windows_core::PCWSTR>,
    P1: windows_core::Param<windows_core::PCWSTR>,
{
    windows_link::link!("mapi32" "system" fn MNLS_lstrcmpW(lpstring1 : windows_core::PCWSTR, lpstring2 : windows_core::PCWSTR) -> i32);
    unsafe { MNLS_lstrcmpW(lpstring1.param().abi(), lpstring2.param().abi()) }
}
#[inline]
pub unsafe fn MNLS_lstrcpyW<P0, P1>(lpstring1: P0, lpstring2: P1) -> windows_core::PWSTR
where
    P0: windows_core::Param<windows_core::PCWSTR>,
    P1: windows_core::Param<windows_core::PCWSTR>,
{
    windows_link::link!("mapi32" "system" fn MNLS_lstrcpyW(lpstring1 : windows_core::PCWSTR, lpstring2 : windows_core::PCWSTR) -> windows_core::PWSTR);
    unsafe { MNLS_lstrcpyW(lpstring1.param().abi(), lpstring2.param().abi()) }
}
#[inline]
pub unsafe fn MNLS_lstrlenW<P0>(lpstring: P0) -> i32
where
    P0: windows_core::Param<windows_core::PCWSTR>,
{
    windows_link::link!("mapi32" "system" fn MNLS_lstrlenW(lpstring : windows_core::PCWSTR) -> i32);
    unsafe { MNLS_lstrlenW(lpstring.param().abi()) }
}
#[inline]
pub unsafe fn MSProviderInit<P1>(
    param0: windows::Win32::Foundation::HINSTANCE,
    param1: P1,
    param2: LPALLOCATEBUFFER,
    param3: LPALLOCATEMORE,
    param4: LPFREEBUFFER,
    param5: u32,
    param6: u32,
    param7: *mut u32,
    param8: *mut Option<IMSProvider>,
) -> windows_core::Result<()>
where
    P1: windows_core::Param<windows::Win32::System::Com::IMalloc>,
{
    windows_link::link!("olmapi32" "cdecl" fn MSProviderInit(param0 : windows::Win32::Foundation:: HINSTANCE, param1 : * mut core::ffi::c_void, param2 : LPALLOCATEBUFFER, param3 : LPALLOCATEMORE, param4 : LPFREEBUFFER, param5 : u32, param6 : u32, param7 : *mut u32, param8 : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        MSProviderInit(
            param0,
            param1.param().abi(),
            param2,
            param3,
            param4,
            param5,
            param6,
            param7 as _,
            core::mem::transmute(param8),
        )
        .ok()
    }
}
#[inline]
pub unsafe fn MapStorageSCode(stgscode: i32) -> i32 {
    windows_link::link!("mapi32" "system" fn MapStorageSCode(stgscode : i32) -> i32);
    unsafe { MapStorageSCode(stgscode) }
}
#[inline]
pub unsafe fn OpenIMsgOnIStg<P4, P6>(
    lpmsgsess: windows::Win32::Storage::Imapi::LPMSGSESS,
    lpallocatebuffer: LPALLOCATEBUFFER,
    lpallocatemore: LPALLOCATEMORE,
    lpfreebuffer: LPFREEBUFFER,
    lpmalloc: P4,
    lpmapisup: *mut core::ffi::c_void,
    lpstg: P6,
    lpfmsgcallrelease: *mut windows::Win32::Storage::Imapi::MSGCALLRELEASE,
    ulcallerdata: u32,
    ulflags: u32,
    lppmsg: *mut Option<IMessage>,
) -> i32
where
    P4: windows_core::Param<windows::Win32::System::Com::IMalloc>,
    P6: windows_core::Param<windows::Win32::System::Com::StructuredStorage::IStorage>,
{
    windows_link::link!("mapi32" "system" fn OpenIMsgOnIStg(lpmsgsess : windows::Win32::Storage::Imapi:: LPMSGSESS, lpallocatebuffer : LPALLOCATEBUFFER, lpallocatemore : LPALLOCATEMORE, lpfreebuffer : LPFREEBUFFER, lpmalloc : * mut core::ffi::c_void, lpmapisup : *mut core::ffi::c_void, lpstg : * mut core::ffi::c_void, lpfmsgcallrelease : *mut windows::Win32::Storage::Imapi:: MSGCALLRELEASE, ulcallerdata : u32, ulflags : u32, lppmsg : *mut * mut core::ffi::c_void) -> i32);
    unsafe {
        OpenIMsgOnIStg(
            lpmsgsess,
            lpallocatebuffer,
            lpallocatemore,
            lpfreebuffer,
            lpmalloc.param().abi(),
            lpmapisup as _,
            lpstg.param().abi(),
            lpfmsgcallrelease as _,
            ulcallerdata,
            ulflags,
            core::mem::transmute(lppmsg),
        )
    }
}
#[inline]
pub unsafe fn OpenIMsgSession<P0>(
    lpmalloc: P0,
    ulflags: u32,
    lppmsgsess: *mut windows::Win32::Storage::Imapi::LPMSGSESS,
) -> i32
where
    P0: windows_core::Param<windows::Win32::System::Com::IMalloc>,
{
    windows_link::link!("mapi32" "system" fn OpenIMsgSession(lpmalloc : * mut core::ffi::c_void, ulflags : u32, lppmsgsess : *mut windows::Win32::Storage::Imapi:: LPMSGSESS) -> i32);
    unsafe { OpenIMsgSession(lpmalloc.param().abi(), ulflags, lppmsgsess as _) }
}
#[inline]
pub unsafe fn OpenStreamOnFile(
    lpallocatebuffer: LPALLOCATEBUFFER,
    lpfreebuffer: LPFREEBUFFER,
    ulflags: u32,
    lpszfilename: *const i8,
    lpszprefix: Option<*const i8>,
) -> windows_core::Result<windows::Win32::System::Com::IStream> {
    windows_link::link!("mapi32" "system" fn OpenStreamOnFile(lpallocatebuffer : LPALLOCATEBUFFER, lpfreebuffer : LPFREEBUFFER, ulflags : u32, lpszfilename : *const i8, lpszprefix : *const i8, lppstream : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        let mut result__ = core::mem::zeroed();
        OpenStreamOnFile(
            lpallocatebuffer,
            lpfreebuffer,
            ulflags,
            lpszfilename,
            lpszprefix.unwrap_or(core::mem::zeroed()) as _,
            &mut result__,
        )
        .and_then(|| windows_core::Type::from_abi(result__))
    }
}
#[inline]
pub unsafe fn PpropFindProp(
    lpproparray: *mut SPropValue,
    cvalues: u32,
    ulproptag: u32,
) -> *mut SPropValue {
    windows_link::link!("mapi32" "system" fn PpropFindProp(lpproparray : *mut SPropValue, cvalues : u32, ulproptag : u32) -> *mut SPropValue);
    unsafe { PpropFindProp(lpproparray as _, cvalues, ulproptag) }
}
#[inline]
pub unsafe fn PropCopyMore(
    lpspropvaluedest: *mut SPropValue,
    lpspropvaluesrc: *mut SPropValue,
    lpfallocmore: LPALLOCATEMORE,
    lpvobject: *mut core::ffi::c_void,
) -> i32 {
    windows_link::link!("mapi32" "system" fn PropCopyMore(lpspropvaluedest : *mut SPropValue, lpspropvaluesrc : *mut SPropValue, lpfallocmore : LPALLOCATEMORE, lpvobject : *mut core::ffi::c_void) -> i32);
    unsafe {
        PropCopyMore(
            lpspropvaluedest as _,
            lpspropvaluesrc as _,
            lpfallocmore,
            lpvobject as _,
        )
    }
}
#[inline]
pub unsafe fn RTFSync<P0>(lpmessage: P0, ulflags: u32) -> windows_core::Result<windows_core::BOOL>
where
    P0: windows_core::Param<IMessage>,
{
    windows_link::link!("mapi32" "system" fn RTFSync(lpmessage : * mut core::ffi::c_void, ulflags : u32, lpfmessageupdated : *mut windows_core::BOOL) -> windows_core::HRESULT);
    unsafe {
        let mut result__ = core::mem::zeroed();
        RTFSync(lpmessage.param().abi(), ulflags, &mut result__).map(|| result__)
    }
}
#[inline]
pub unsafe fn ScBinFromHexBounded(lpsz: *const i8, lpb: *mut u8, cb: u32) -> i32 {
    windows_link::link!("mapi32" "system" fn ScBinFromHexBounded(lpsz : *const i8, lpb : *mut u8, cb : u32) -> i32);
    unsafe { ScBinFromHexBounded(lpsz, lpb as _, cb) }
}
#[inline]
pub unsafe fn ScCopyNotifications(
    cnotification: i32,
    lpnotifications: *mut NOTIFICATION,
    lpvdst: *mut core::ffi::c_void,
    lpcb: *mut u32,
) -> i32 {
    windows_link::link!("mapi32" "system" fn ScCopyNotifications(cnotification : i32, lpnotifications : *mut NOTIFICATION, lpvdst : *mut core::ffi::c_void, lpcb : *mut u32) -> i32);
    unsafe { ScCopyNotifications(cnotification, lpnotifications as _, lpvdst as _, lpcb as _) }
}
#[inline]
pub unsafe fn ScCopyProps(
    cvalues: i32,
    lpproparray: *mut SPropValue,
    lpvdst: *mut core::ffi::c_void,
    lpcb: *mut u32,
) -> i32 {
    windows_link::link!("mapi32" "system" fn ScCopyProps(cvalues : i32, lpproparray : *mut SPropValue, lpvdst : *mut core::ffi::c_void, lpcb : *mut u32) -> i32);
    unsafe { ScCopyProps(cvalues, lpproparray as _, lpvdst as _, lpcb as _) }
}
#[inline]
pub unsafe fn ScCountNotifications(
    cnotifications: i32,
    lpnotifications: *mut NOTIFICATION,
    lpcb: *mut u32,
) -> i32 {
    windows_link::link!("mapi32" "system" fn ScCountNotifications(cnotifications : i32, lpnotifications : *mut NOTIFICATION, lpcb : *mut u32) -> i32);
    unsafe { ScCountNotifications(cnotifications, lpnotifications as _, lpcb as _) }
}
#[inline]
pub unsafe fn ScCountProps(cvalues: i32, lpproparray: *mut SPropValue, lpcb: *mut u32) -> i32 {
    windows_link::link!("mapi32" "system" fn ScCountProps(cvalues : i32, lpproparray : *mut SPropValue, lpcb : *mut u32) -> i32);
    unsafe { ScCountProps(cvalues, lpproparray as _, lpcb as _) }
}
#[inline]
pub unsafe fn ScCreateConversationIndex(
    cbparent: u32,
    lpbparent: *mut u8,
    lpcbconvindex: *mut u32,
    lppbconvindex: *mut *mut u8,
) -> i32 {
    windows_link::link!("mapi32" "system" fn ScCreateConversationIndex(cbparent : u32, lpbparent : *mut u8, lpcbconvindex : *mut u32, lppbconvindex : *mut *mut u8) -> i32);
    unsafe {
        ScCreateConversationIndex(
            cbparent,
            lpbparent as _,
            lpcbconvindex as _,
            lppbconvindex as _,
        )
    }
}
#[inline]
pub unsafe fn ScDupPropset(
    cvalues: i32,
    lpproparray: *mut SPropValue,
    lpallocatebuffer: LPALLOCATEBUFFER,
    lppproparray: *mut *mut SPropValue,
) -> i32 {
    windows_link::link!("mapi32" "system" fn ScDupPropset(cvalues : i32, lpproparray : *mut SPropValue, lpallocatebuffer : LPALLOCATEBUFFER, lppproparray : *mut *mut SPropValue) -> i32);
    unsafe {
        ScDupPropset(
            cvalues,
            lpproparray as _,
            lpallocatebuffer,
            lppproparray as _,
        )
    }
}
#[inline]
pub unsafe fn ScInitMapiUtil(ulflags: u32) -> i32 {
    windows_link::link!("mapi32" "system" fn ScInitMapiUtil(ulflags : u32) -> i32);
    unsafe { ScInitMapiUtil(ulflags) }
}
#[inline]
pub unsafe fn ScLocalPathFromUNC<P0, P1>(lpszunc: P0, lpszlocal: P1, cchlocal: u32) -> i32
where
    P0: windows_core::Param<windows_core::PCSTR>,
    P1: windows_core::Param<windows_core::PCSTR>,
{
    windows_link::link!("mapi32" "system" fn ScLocalPathFromUNC(lpszunc : windows_core::PCSTR, lpszlocal : windows_core::PCSTR, cchlocal : u32) -> i32);
    unsafe { ScLocalPathFromUNC(lpszunc.param().abi(), lpszlocal.param().abi(), cchlocal) }
}
#[inline]
pub unsafe fn ScMAPIXFromSMAPI(
    lhsimplesession: usize,
    ulflags: u32,
    lpinterface: *mut windows_core::GUID,
    lppmapisession: *mut Option<IMAPISession>,
) -> i32 {
    windows_link::link!("mapi32" "system" fn ScMAPIXFromSMAPI(lhsimplesession : usize, ulflags : u32, lpinterface : *mut windows_core::GUID, lppmapisession : *mut * mut core::ffi::c_void) -> i32);
    unsafe {
        ScMAPIXFromSMAPI(
            lhsimplesession,
            ulflags,
            lpinterface as _,
            core::mem::transmute(lppmapisession),
        )
    }
}
#[inline]
pub unsafe fn ScRelocNotifications(
    cnotification: i32,
    lpnotifications: *mut NOTIFICATION,
    lpvbaseold: *mut core::ffi::c_void,
    lpvbasenew: *mut core::ffi::c_void,
    lpcb: *mut u32,
) -> i32 {
    windows_link::link!("mapi32" "system" fn ScRelocNotifications(cnotification : i32, lpnotifications : *mut NOTIFICATION, lpvbaseold : *mut core::ffi::c_void, lpvbasenew : *mut core::ffi::c_void, lpcb : *mut u32) -> i32);
    unsafe {
        ScRelocNotifications(
            cnotification,
            lpnotifications as _,
            lpvbaseold as _,
            lpvbasenew as _,
            lpcb as _,
        )
    }
}
#[inline]
pub unsafe fn ScRelocProps(
    cvalues: i32,
    lpproparray: *mut SPropValue,
    lpvbaseold: *mut core::ffi::c_void,
    lpvbasenew: *mut core::ffi::c_void,
    lpcb: *mut u32,
) -> i32 {
    windows_link::link!("mapi32" "system" fn ScRelocProps(cvalues : i32, lpproparray : *mut SPropValue, lpvbaseold : *mut core::ffi::c_void, lpvbasenew : *mut core::ffi::c_void, lpcb : *mut u32) -> i32);
    unsafe {
        ScRelocProps(
            cvalues,
            lpproparray as _,
            lpvbaseold as _,
            lpvbasenew as _,
            lpcb as _,
        )
    }
}
#[inline]
pub unsafe fn ScUNCFromLocalPath<P0, P1>(lpszlocal: P0, lpszunc: P1, cchunc: u32) -> i32
where
    P0: windows_core::Param<windows_core::PCSTR>,
    P1: windows_core::Param<windows_core::PCSTR>,
{
    windows_link::link!("mapi32" "system" fn ScUNCFromLocalPath(lpszlocal : windows_core::PCSTR, lpszunc : windows_core::PCSTR, cchunc : u32) -> i32);
    unsafe { ScUNCFromLocalPath(lpszlocal.param().abi(), lpszunc.param().abi(), cchunc) }
}
#[inline]
pub unsafe fn SetAttribIMsgOnIStg(
    lpobject: *mut core::ffi::c_void,
    lpproptags: *mut SPropTagArray,
    lppropattrs: *mut SPropAttrArray,
    lpppropproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()> {
    windows_link::link!("mapi32" "system" fn SetAttribIMsgOnIStg(lpobject : *mut core::ffi::c_void, lpproptags : *mut SPropTagArray, lppropattrs : *mut SPropAttrArray, lpppropproblems : *mut *mut SPropProblemArray) -> windows_core::HRESULT);
    unsafe {
        SetAttribIMsgOnIStg(
            lpobject as _,
            lpproptags as _,
            lppropattrs as _,
            lpppropproblems as _,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn SzFindCh(lpsz: *mut i8, ch: u16) -> *mut i8 {
    windows_link::link!("mapi32" "system" fn SzFindCh(lpsz : *mut i8, ch : u16) -> *mut i8);
    unsafe { SzFindCh(lpsz as _, ch) }
}
#[inline]
pub unsafe fn SzFindLastCh(lpsz: *mut i8, ch: u16) -> *mut i8 {
    windows_link::link!("mapi32" "system" fn SzFindLastCh(lpsz : *mut i8, ch : u16) -> *mut i8);
    unsafe { SzFindLastCh(lpsz as _, ch) }
}
#[inline]
pub unsafe fn SzFindSz(lpsz: *mut i8, lpszkey: *mut i8) -> *mut i8 {
    windows_link::link!("mapi32" "system" fn SzFindSz(lpsz : *mut i8, lpszkey : *mut i8) -> *mut i8);
    unsafe { SzFindSz(lpsz as _, lpszkey as _) }
}
#[inline]
pub unsafe fn UFromSz(lpsz: *mut i8) -> u32 {
    windows_link::link!("mapi32" "system" fn UFromSz(lpsz : *mut i8) -> u32);
    unsafe { UFromSz(lpsz as _) }
}
#[inline]
pub unsafe fn UlAddRef(lpunk: *mut core::ffi::c_void) -> u32 {
    windows_link::link!("mapi32" "system" fn UlAddRef(lpunk : *mut core::ffi::c_void) -> u32);
    unsafe { UlAddRef(lpunk as _) }
}
#[inline]
pub unsafe fn UlFromSzHex(lpsz: *mut i8) -> u32 {
    windows_link::link!("mapi32" "system" fn UlFromSzHex(lpsz : *mut i8) -> u32);
    unsafe { UlFromSzHex(lpsz as _) }
}
#[inline]
pub unsafe fn UlPropSize(lpspropvalue: *mut SPropValue) -> u32 {
    windows_link::link!("mapi32" "system" fn UlPropSize(lpspropvalue : *mut SPropValue) -> u32);
    unsafe { UlPropSize(lpspropvalue as _) }
}
#[inline]
pub unsafe fn UlRelease(lpunk: *mut core::ffi::c_void) -> u32 {
    windows_link::link!("mapi32" "system" fn UlRelease(lpunk : *mut core::ffi::c_void) -> u32);
    unsafe { UlRelease(lpunk as _) }
}
#[inline]
pub unsafe fn WrapCompressedRTFStream<P0>(
    lpcompressedrtfstream: P0,
    ulflags: u32,
) -> windows_core::Result<windows::Win32::System::Com::IStream>
where
    P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
    windows_link::link!("mapi32" "system" fn WrapCompressedRTFStream(lpcompressedrtfstream : * mut core::ffi::c_void, ulflags : u32, lpuncompressedrtfstream : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe {
        let mut result__ = core::mem::zeroed();
        WrapCompressedRTFStream(lpcompressedrtfstream.param().abi(), ulflags, &mut result__)
            .and_then(|| windows_core::Type::from_abi(result__))
    }
}
#[inline]
pub unsafe fn WrapStoreEntryID(
    ulflags: u32,
    lpszdllname: *const i8,
    cborigentry: u32,
    lporigentry: *mut ENTRYID,
    lpcbwrappedentry: *mut u32,
    lppwrappedentry: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
    windows_link::link!("mapi32" "system" fn WrapStoreEntryID(ulflags : u32, lpszdllname : *const i8, cborigentry : u32, lporigentry : *mut ENTRYID, lpcbwrappedentry : *mut u32, lppwrappedentry : *mut *mut ENTRYID) -> windows_core::HRESULT);
    unsafe {
        WrapStoreEntryID(
            ulflags,
            lpszdllname,
            cborigentry,
            lporigentry as _,
            lpcbwrappedentry as _,
            lppwrappedentry as _,
        )
        .ok()
    }
}
#[inline]
pub unsafe fn __CPPValidateParameters(
    emethod: METHODS,
    ppfirst: *const core::ffi::c_void,
) -> windows_core::Result<()> {
    windows_link::link!("mapi32" "system" fn __CPPValidateParameters(emethod : METHODS, ppfirst : *const core::ffi::c_void) -> windows_core::HRESULT);
    unsafe { __CPPValidateParameters(emethod, ppfirst).ok() }
}
#[inline]
pub unsafe fn __ValidateParameters(
    emethod: METHODS,
    ppthis: *mut core::ffi::c_void,
) -> windows_core::Result<()> {
    windows_link::link!("mapi32" "system" fn __ValidateParameters(emethod : METHODS, ppthis : *mut core::ffi::c_void) -> windows_core::HRESULT);
    unsafe { __ValidateParameters(emethod, ppthis as _).ok() }
}
pub const ABORT_XP_HEADER_OPERATION: u32 = 2097152u32;
pub type ABPROVIDERINIT = Option<
    unsafe extern "system" fn(
        hinstance: windows::Win32::Foundation::HINSTANCE,
        lpmalloc: windows_core::Ref<'_, windows::Win32::System::Com::IMalloc>,
        lpallocatebuffer: LPALLOCATEBUFFER,
        lpallocatemore: LPALLOCATEMORE,
        lpfreebuffer: LPFREEBUFFER,
        ulflags: u32,
        ulmapiver: u32,
        lpulproviderver: *mut u32,
        lppabprovider: windows_core::OutRef<'_, IABProvider>,
    ) -> windows_core::HRESULT,
>;
pub const AB_FIND_ON_OPEN: u32 = 16u32;
pub const AB_MODIFIABLE: u32 = 4u32;
pub const AB_NOT_DEFAULT: u32 = 32u32;
pub const AB_NO_DIALOG: u32 = 1u32;
pub const AB_RECIPIENTS: u32 = 1u32;
pub const AB_RESOLVE: u32 = 32u32;
pub const AB_SELECTONLY: u32 = 16u32;
pub const AB_SHOW_OTHERS: u32 = 4u32;
pub const AB_SHOW_PHANTOMS: u32 = 2u32;
pub const AB_SUBCONTAINERS: u32 = 2u32;
pub const AB_UNICODEUI: u32 = 64u32;
pub const AB_UNMODIFIABLE: u32 = 8u32;
pub const ACCTUI_NO_WARNING: u32 = 256u32;
pub const ACCTUI_SHOW_ACCTWIZARD: u32 = 1024u32;
pub const ACCTUI_SHOW_DATA_TAB: u32 = 512u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ACCT_BIN {
    pub cb: u32,
    pub pb: *mut u8,
}
impl Default for ACCT_BIN {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const ACCT_INIT_NOSYNCH_MAPI_ACCTS: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct ACCT_VARIANT {
    pub dwType: u32,
    pub Val: ACCT_VARIANT_0,
}
impl Default for ACCT_VARIANT {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union ACCT_VARIANT_0 {
    pub dw: u32,
    pub pwsz: windows_core::PWSTR,
    pub bin: ACCT_BIN,
}
impl Default for ACCT_VARIANT_0 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const ACLTABLE_FREEBUSY: u32 = 2u32;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct ACTION {
    pub acttype: ACTTYPE,
    pub ulActionFlavor: u32,
    pub lpRes: *mut SRestriction,
    pub lpPropTagArray: *mut SPropTagArray,
    pub ulFlags: u32,
    pub dwAlignPad: u32,
    pub Anonymous: ACTION_0,
}
impl Default for ACTION {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union ACTION_0 {
    pub actMoveCopy: ACTION_0_0,
    pub actReply: ACTION_0_1,
    pub actDeferAction: ACTION_0_2,
    pub scBounceCode: i32,
    pub lpadrlist: *mut ADRLIST,
    pub propTag: SPropValue,
}
impl Default for ACTION_0 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ACTION_0_2 {
    pub cbData: u32,
    pub pbData: *mut u8,
}
impl Default for ACTION_0_2 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ACTION_0_0 {
    pub cbStoreEntryId: u32,
    pub lpStoreEntryId: *mut ENTRYID,
    pub cbFldEntryId: u32,
    pub lpFldEntryId: *mut ENTRYID,
}
impl Default for ACTION_0_0 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ACTION_0_1 {
    pub cbEntryId: u32,
    pub lpEntryId: *mut ENTRYID,
    pub guidReplyTemplate: windows_core::GUID,
}
impl Default for ACTION_0_1 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ACTIONS {
    pub ulVersion: u32,
    pub cActions: u32,
    pub lpAction: *mut ACTION,
}
impl Default for ACTIONS {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct ACTTYPE(pub i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct ADDRESSFORMAT(pub i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ADDRESSLIST {
    pub cAdrs: u32,
    pub prgAdr: *mut ADDRESSPROPS,
}
impl Default for ADDRESSLIST {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ADDRESSPROPS {
    pub dwProps: u32,
    pub hAddress: *mut HADDRESS__,
    pub ietFriendly: ENCODINGTYPE,
    pub hCharset: *mut HCHARSET__,
    pub dwAdrType: u32,
    pub pszFriendly: windows_core::PSTR,
    pub pwszReserved: windows_core::PWSTR,
    pub pszEmail: windows_core::PSTR,
    pub certstate: CERTSTATE,
    pub tbSigning: windows::Win32::System::Com::BLOB,
    pub tbEncryption: windows::Win32::System::Com::BLOB,
    pub dwCookie: u32,
    pub dwReserved1: u32,
    pub dwReserved2: u32,
}
impl Default for ADDRESSPROPS {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const ADDRESS_ONE: u32 = 8u32;
pub const ADMN_PAD: u32 = 3u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ADRENTRY {
    pub ulReserved1: u32,
    pub cValues: u32,
    pub rgPropVals: *mut SPropValue,
}
impl Default for ADRENTRY {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ADRLIST {
    pub cEntries: u32,
    pub aEntries: [ADRENTRY; 1],
}
impl Default for ADRLIST {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ADRPARM {
    pub cbABContEntryID: u32,
    pub lpABContEntryID: *mut ENTRYID,
    pub ulFlags: u32,
    pub lpReserved: *mut core::ffi::c_void,
    pub ulHelpContext: u32,
    pub lpszHelpFileName: *mut i8,
    pub lpfnABSDI: LPFNABSDI,
    pub lpfnDismiss: LPFNDISMISS,
    pub lpvDismissContext: *mut core::ffi::c_void,
    pub lpszCaption: *mut i8,
    pub lpszNewEntryTitle: *mut i8,
    pub lpszDestWellsTitle: *mut i8,
    pub cDestFields: u32,
    pub nDestFieldFocus: u32,
    pub lppszDestTitles: *mut *mut i8,
    pub lpulDestComps: *mut u32,
    pub lpContRestriction: *mut SRestriction,
    pub lpHierRestriction: *mut SRestriction,
}
impl Default for ADRPARM {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const ADRPARM_HELP_CTX: u32 = 0u32;
pub const AFT_DISPLAY_BOTH: ADDRESSFORMAT = ADDRESSFORMAT(2i32);
pub const AFT_DISPLAY_EMAIL: ADDRESSFORMAT = ADDRESSFORMAT(1i32);
pub const AFT_DISPLAY_FRIENDLY: ADDRESSFORMAT = ADDRESSFORMAT(0i32);
pub const AFT_RFC822_DECODED: ADDRESSFORMAT = ADDRESSFORMAT(3i32);
pub const AFT_RFC822_ENCODED: ADDRESSFORMAT = ADDRESSFORMAT(4i32);
pub const AFT_RFC822_TRANSMIT: ADDRESSFORMAT = ADDRESSFORMAT(5i32);
pub const AG_DAYS: u32 = 2u32;
pub const AG_MONTHS: u32 = 0u32;
pub const AG_WEEKS: u32 = 1u32;
pub const ANTIVIRUS_SCAN_NO_VIRUS: u32 = 0u32;
pub const ANTIVIRUS_SCAN_VIRUS_CLEANED: u32 = 2u32;
pub const ANTIVIRUS_SCAN_VIRUS_DELETED: u32 = 3u32;
pub const ANTIVIRUS_SCAN_VIRUS_PRESENT: u32 = 1u32;
pub const ATTACH_BY_REFERENCE: u32 = 2u32;
pub const ATTACH_BY_REF_ONLY: u32 = 4u32;
pub const ATTACH_BY_REF_RESOLVE: u32 = 3u32;
pub const ATTACH_BY_VALUE: u32 = 1u32;
pub const ATTACH_BY_WEBREFERENCE: u32 = 7u32;
pub const ATTACH_DIALOG: u32 = 1u32;
pub const ATTACH_EMBEDDED_MSG: u32 = 5u32;
pub const ATTACH_OLE: u32 = 6u32;
pub const AUTO_RESPONSE_SUPPRESS_AUTO_REPLY: u32 = 32u32;
pub const AUTO_RESPONSE_SUPPRESS_DR: u32 = 1u32;
pub const AUTO_RESPONSE_SUPPRESS_NDR: u32 = 2u32;
pub const AUTO_RESPONSE_SUPPRESS_NORFC821FROM: u32 = 64u32;
pub const AUTO_RESPONSE_SUPPRESS_NRN: u32 = 8u32;
pub const AUTO_RESPONSE_SUPPRESS_OOF: u32 = 16u32;
pub const AUTO_RESPONSE_SUPPRESS_RN: u32 = 4u32;
pub const BACKGROUND_SEARCH: u32 = 32u32;
pub const BEGIN_DEFERRED: u32 = 1u32;
pub const BMR_EQZ: u32 = 0u32;
pub const BMR_NEZ: u32 = 1u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct BODYLOCATION(pub i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct BODYOFFSETS {
    pub cbBoundaryStart: u32,
    pub cbHeaderStart: u32,
    pub cbBodyStart: u32,
    pub cbBodyEnd: u32,
}
impl Default for BODYOFFSETS {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const BOOKMARK_BEGINNING: u32 = 0u32;
pub const BOOKMARK_CURRENT: u32 = 1u32;
pub const BOOKMARK_END: u32 = 2u32;
pub const CALLBACK_DISCONTINUE: u32 = 2147483648u32;
pub type CALLERRELEASE = Option<
    unsafe extern "system" fn(
        ulcallerdata: usize,
        lptbldata: windows_core::Ref<'_, ITableData>,
        lpvue: windows_core::Ref<'_, IMAPITable>,
    ),
>;
pub const CB_OID_1: u32 = 9u32;
pub const CB_OID_2: u32 = 10u32;
pub const CB_OID_3: u32 = 11u32;
pub const CB_OID_4: u32 = 12u32;
pub const CB_OID_MAC_BINARY: u32 = 9u32;
pub const CB_OID_MIMETAG: u32 = 9u32;
pub const CB_OID_OLE: u32 = 9u32;
pub const CB_OID_OLE1: u32 = 10u32;
pub const CB_OID_OLE1_STORAGE: u32 = 11u32;
pub const CB_OID_OLE2: u32 = 10u32;
pub const CB_OID_OLE2_STORAGE: u32 = 11u32;
pub const CB_OID_TNEF: u32 = 9u32;
pub const CCHMAX_CID: u32 = 255u32;
pub const CCHMAX_CSET_NAME: u32 = 128u32;
pub const CCHMAX_FACE_NAME: u32 = 128u32;
pub const CCHMAX_HEADER_LINE: u32 = 1000u32;
pub const CCHMAX_INTERNET_DATE: u32 = 50u32;
pub const CCHMAX_LANG_NAME: u32 = 128u32;
pub const CCHMAX_MID: u32 = 255u32;
pub const CDID_EMAIL: CERTDATAID = CERTDATAID(0i32);
pub const CDID_MAX: CERTDATAID = CERTDATAID(1i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CERTDATAID(pub i32);
pub const CERTIFICATE_CHAIN_TOO_LONG: CERTSTATE = CERTSTATE(3i32);
pub const CERTIFICATE_CRL_LISTED: CERTSTATE = CERTSTATE(5i32);
pub const CERTIFICATE_ERROR: CERTSTATE = CERTSTATE(8i32);
pub const CERTIFICATE_EXPIRED: CERTSTATE = CERTSTATE(2i32);
pub const CERTIFICATE_INVALID: CERTSTATE = CERTSTATE(7i32);
pub const CERTIFICATE_MISSING_ISSUER: CERTSTATE = CERTSTATE(4i32);
pub const CERTIFICATE_NOPRINT: CERTSTATE = CERTSTATE(9i32);
pub const CERTIFICATE_NOT_PRESENT: CERTSTATE = CERTSTATE(1i32);
pub const CERTIFICATE_NOT_TRUSTED: CERTSTATE = CERTSTATE(6i32);
pub const CERTIFICATE_OK: CERTSTATE = CERTSTATE(0i32);
pub const CERTIFICATE_UNKNOWN: CERTSTATE = CERTSTATE(10i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CERTNAMETYPE(pub i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CERTSTATE(pub i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CHARSETTYPE(pub i32);
pub const CHARSET_BODY: CHARSETTYPE = CHARSETTYPE(0i32);
pub const CHARSET_HEADER: CHARSETTYPE = CHARSETTYPE(1i32);
pub const CHARSET_WEB: CHARSETTYPE = CHARSETTYPE(2i32);
pub const CHECK_SENDER: u32 = 1u32;
pub const CLEAR_NRN_PENDING: u32 = 64u32;
pub const CLEAR_READ_FLAG: u32 = 4u32;
pub const CLEAR_RN_PENDING: u32 = 32u32;
pub const CLSID_IMimeHtmlProtocol: windows_core::GUID =
    windows_core::GUID::from_u128(0x05300401_bcbc_11d0_85e3_00c04fd85ab4);
pub const CLSID_IVirtualStream: windows_core::GUID =
    windows_core::GUID::from_u128(0xfd853cdf_7f86_11d0_8252_00c04fd85ab4);
pub const CLSID_MimeEdit: windows_core::GUID =
    windows_core::GUID::from_u128(0x1c82ead9_508e_11d1_8dcf_00c04fb951f9);
pub const CLSID_OlkAccountManager: windows_core::GUID =
    windows_core::GUID::from_u128(0xed475410_b0d6_11d2_8c3b_00104b2a6676);
pub const CLSID_OlkAddressBook: windows_core::GUID =
    windows_core::GUID::from_u128(0xed475419_b0d6_11d2_8c3b_00104b2a6676);
pub const CLSID_OlkHotmailAccount: windows_core::GUID =
    windows_core::GUID::from_u128(0x4db5cbf0_3b77_4852_bc8e_bb81908861f3);
pub const CLSID_OlkIMAP4Account: windows_core::GUID =
    windows_core::GUID::from_u128(0xed475412_b0d6_11d2_8c3b_00104b2a6676);
pub const CLSID_OlkLDAPAccount: windows_core::GUID =
    windows_core::GUID::from_u128(0x4db5cbf2_3b77_4852_bc8e_bb81908861f3);
pub const CLSID_OlkMAPIAccount: windows_core::GUID =
    windows_core::GUID::from_u128(0xed475414_b0d6_11d2_8c3b_00104b2a6676);
pub const CLSID_OlkMail: windows_core::GUID =
    windows_core::GUID::from_u128(0xed475418_b0d6_11d2_8c3b_00104b2a6676);
pub const CLSID_OlkPOP3Account: windows_core::GUID =
    windows_core::GUID::from_u128(0xed475411_b0d6_11d2_8c3b_00104b2a6676);
pub const CLSID_OlkStore: windows_core::GUID =
    windows_core::GUID::from_u128(0xed475420_b0d6_11d2_8c3b_00104b2a6676);
pub const CMDSETID_MimeEdit: windows_core::GUID =
    windows_core::GUID::from_u128(0x1c82eada_508e_11d1_8dcf_00c04fb951f9);
pub const CMDSETID_MimeEditHost: windows_core::GUID =
    windows_core::GUID::from_u128(0x1c82eadb_508e_11d1_8dcf_00c04fb951f9);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct CODEPAGEINFO {
    pub dwMask: u32,
    pub cpiCodePage: u32,
    pub fIsValidCodePage: windows_core::BOOL,
    pub ulMaxCharSize: u32,
    pub fInternetCP: windows_core::BOOL,
    pub cpiFamily: u32,
    pub szName: [i8; 128],
    pub szBodyCset: [i8; 128],
    pub szHeaderCset: [i8; 128],
    pub szWebCset: [i8; 128],
    pub szFixedFont: [i8; 128],
    pub szVariableFont: [i8; 128],
    pub ietNewsDefault: ENCODINGTYPE,
    pub ietMailDefault: ENCODINGTYPE,
    pub dwReserved1: u32,
}
impl Default for CODEPAGEINFO {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const COMMIT_ONLYIFDIRTY: u32 = 1u32;
pub const COMMIT_REUSESTORAGE: u32 = 2u32;
pub const COMMIT_SMIMETRANSFERENCODE: u32 = 4u32;
pub const CONFIG_CHANGED: u32 = 1048576u32;
pub const CONFIG_NO_AUTO_DETECT: u32 = 16u32;
pub const CONFIG_OST_CACHE_ONLY: u32 = 32u32;
pub const CONFIG_PROMPT_FOR_CREDENTIALS: u32 = 8u32;
pub const CONFIG_SERVICE: u32 = 1u32;
pub const CONFIG_SHOW_CONNECT_UI: u32 = 4u32;
pub const CONFIG_SHOW_STARTUP_UI: u32 = 2u32;
pub const CONNECT_ANONYMOUS_ACCESS: u32 = 16u32;
pub const CONNECT_NO_ADDRESS_RESOLUTION: u32 = 64u32;
pub const CONNECT_NO_NOTIFICATIONS: u32 = 32u32;
pub const CONNECT_NO_RPC_ENCRYPTION: u32 = 2u32;
pub const CONNECT_NO_TABLE_NOTIFICATIONS: u32 = 32u32;
pub const CONNECT_NO_UNDER_COVER_CONNECTION: u32 = 8u32;
pub const CONNECT_RESTORE_DATABASE: u32 = 128u32;
pub const CONNECT_USE_ADMIN_PRIVILEGE: u32 = 1u32;
pub const CONNECT_USE_SEPARATE_CONNECTION: u32 = 4u32;
pub const CONVENIENT_DEPTH: u32 = 1u32;
pub const COPY_SUBFOLDERS: u32 = 16u32;
pub const COUNTRY_PAD: u32 = 0u32;
pub const CP_ACP: u32 = 0u32;
pub const CP_ISO2022JPESC: u32 = 50221u32;
pub const CP_ISO2022JPSIO: u32 = 50222u32;
pub const CP_JAUTODETECT: u32 = 50932u32;
pub const CP_KAUTODETECT: u32 = 50949u32;
pub const CP_OEMCP: u32 = 1u32;
pub const CP_UNICODE: u32 = 1200u32;
pub const CP_USASCII: u32 = 1252u32;
pub const CREATE_ALWAYS: u32 = 2u32;
pub const CREATE_CHECK_DUP_LOOSE: u32 = 2u32;
pub const CREATE_CHECK_DUP_STRICT: u32 = 1u32;
pub const CREATE_NEW: u32 = 1u32;
pub const CREATE_REPLACE: u32 = 4u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CSETAPPLYTYPE(pub i32);
pub const CSET_APPLY_ALL: CSETAPPLYTYPE = CSETAPPLYTYPE(1i32);
pub const CSET_APPLY_TAG_ALL: CSETAPPLYTYPE = CSETAPPLYTYPE(2i32);
pub const CSET_APPLY_UNTAGGED: CSETAPPLYTYPE = CSETAPPLYTYPE(0i32);
pub const CURRENT_SPI_VERSION: i32 = 65552i32;
pub const DEF_ALLOW_8BIT_HEADER: u32 = 0u32;
pub const DEF_BODY_REMOVE_NBSP: u32 = 1u32;
pub const DEF_CAN_INLINE_TEXT_BODIES: u32 = 0u32;
pub const DEF_CBMAX_BODY_LINE: u32 = 74u32;
pub const DEF_CBMAX_HEADER_LINE: u32 = 1000u32;
pub const DEF_CLEANUP_TREE_ON_SAVE: u32 = 1u32;
pub const DEF_DBCS_ESCAPE_IS_8BIT: u32 = 0u32;
pub const DEF_DECODE_RFC1154: u32 = 0u32;
pub const DEF_ENCRYPTION_ALG_ID: u32 = 26114u32;
pub const DEF_GENERATE_MESSAGE_ID: u32 = 0u32;
pub const DEF_HANDSOFF_ONSAVE: u32 = 0u32;
pub const DEF_HASH_ALG_ID: u32 = 32772u32;
pub const DEF_HIDE_TNEF_ATTACHMENTS: u32 = 1u32;
pub const DEF_INCLUDE_SENDER_CERT: u32 = 0u32;
pub const DEF_LOAD_USE_BIND_FILE: u32 = 0u32;
pub const DEF_NO_DEFAULT_CNTTYPE: u32 = 0u32;
pub const DEF_SAVEBODY_KEEPBOUNDARY: u32 = 0u32;
pub const DEF_SECURITY_IGNOREMASK: u32 = 0u32;
pub const DEF_SHOW_MACBINARY: u32 = 0u32;
pub const DEF_SUPPORT_EXTERNAL_BODY: u32 = 0u32;
pub const DEF_WRAP_BODY_TEXT: u32 = 1u32;
pub const DEINIT_HURRY: u32 = 2147483648u32;
pub const DEINIT_NORMAL: u32 = 1u32;
pub const DELETE_CHILDREN_ONLY: u32 = 2u32;
pub const DELETE_HARD_DELETE: u32 = 16u32;
pub const DELETE_PROMOTE_CHILDREN: u32 = 1u32;
pub const DEL_ASSOCIATED: u32 = 8u32;
pub const DEL_FOLDERS: u32 = 4u32;
pub const DEL_MESSAGES: u32 = 1u32;
pub const DIALOG_ALLOW_CANCEL: u32 = 128u32;
pub const DIALOG_ATTACH: u32 = 8u32;
pub const DIALOG_CONFIRM_CANCEL: u32 = 256u32;
pub const DIALOG_COPY: u32 = 32u32;
pub const DIALOG_DELETE: u32 = 64u32;
pub const DIALOG_FOLDER: u32 = 1u32;
pub const DIALOG_MESSAGE: u32 = 2u32;
pub const DIALOG_MODAL: u32 = 1u32;
pub const DIALOG_MOVE: u32 = 16u32;
pub const DIALOG_OPTIONS: u32 = 4u32;
pub const DIALOG_PROP: u32 = 4u32;
pub const DIALOG_SDI: u32 = 2u32;
pub const DIR_BACKWARD: u32 = 1u32;
pub const DO_NOT_SEND_TO_ORIGINATOR: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLBUTTON {
    pub ulbLpszLabel: u32,
    pub ulFlags: u32,
    pub ulPRControl: u32,
}
impl Default for DTBLBUTTON {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLCHECKBOX {
    pub ulbLpszLabel: u32,
    pub ulFlags: u32,
    pub ulPRPropertyName: u32,
}
impl Default for DTBLCHECKBOX {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLCOMBOBOX {
    pub ulbLpszCharsAllowed: u32,
    pub ulFlags: u32,
    pub ulNumCharsAllowed: u32,
    pub ulPRPropertyName: u32,
    pub ulPRTableName: u32,
}
impl Default for DTBLCOMBOBOX {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLDDLBX {
    pub ulFlags: u32,
    pub ulPRDisplayProperty: u32,
    pub ulPRSetProperty: u32,
    pub ulPRTableName: u32,
}
impl Default for DTBLDDLBX {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLEDIT {
    pub ulbLpszCharsAllowed: u32,
    pub ulFlags: u32,
    pub ulNumCharsAllowed: u32,
    pub ulPropTag: u32,
}
impl Default for DTBLEDIT {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLGROUPBOX {
    pub ulbLpszLabel: u32,
    pub ulFlags: u32,
}
impl Default for DTBLGROUPBOX {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLLABEL {
    pub ulbLpszLabelName: u32,
    pub ulFlags: u32,
}
impl Default for DTBLLABEL {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLLBX {
    pub ulFlags: u32,
    pub ulPRSetProperty: u32,
    pub ulPRTableName: u32,
}
impl Default for DTBLLBX {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLMVDDLBX {
    pub ulFlags: u32,
    pub ulMVPropTag: u32,
}
impl Default for DTBLMVDDLBX {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLMVLISTBOX {
    pub ulFlags: u32,
    pub ulMVPropTag: u32,
}
impl Default for DTBLMVLISTBOX {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLPAGE {
    pub ulbLpszLabel: u32,
    pub ulFlags: u32,
    pub ulbLpszComponent: u32,
    pub ulContext: u32,
}
impl Default for DTBLPAGE {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLRADIOBUTTON {
    pub ulbLpszLabel: u32,
    pub ulFlags: u32,
    pub ulcButtons: u32,
    pub ulPropTag: u32,
    pub lReturnValue: i32,
}
impl Default for DTBLRADIOBUTTON {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct DTCTL {
    pub ulCtlType: u32,
    pub ulCtlFlags: u32,
    pub lpbNotif: *mut u8,
    pub cbNotif: u32,
    pub lpszFilter: *mut i8,
    pub ulItemID: u32,
    pub ctl: DTCTL_0,
}
impl Default for DTCTL {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union DTCTL_0 {
    pub lpv: *mut core::ffi::c_void,
    pub lplabel: *mut DTBLLABEL,
    pub lpedit: *mut DTBLEDIT,
    pub lplbx: *mut DTBLLBX,
    pub lpcombobox: *mut DTBLCOMBOBOX,
    pub lpddlbx: *mut DTBLDDLBX,
    pub lpcheckbox: *mut DTBLCHECKBOX,
    pub lpgroupbox: *mut DTBLGROUPBOX,
    pub lpbutton: *mut DTBLBUTTON,
    pub lpradiobutton: *mut DTBLRADIOBUTTON,
    pub lpmvlbx: *mut DTBLMVLISTBOX,
    pub lpmvddlbx: *mut DTBLMVDDLBX,
    pub lppage: *mut DTBLPAGE,
}
impl Default for DTCTL_0 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const DTCT_BUTTON: u32 = 7u32;
pub const DTCT_CHECKBOX: u32 = 5u32;
pub const DTCT_COMBOBOX: u32 = 3u32;
pub const DTCT_DDLBX: u32 = 4u32;
pub const DTCT_EDIT: u32 = 1u32;
pub const DTCT_GROUPBOX: u32 = 6u32;
pub const DTCT_LABEL: u32 = 0u32;
pub const DTCT_LBX: u32 = 2u32;
pub const DTCT_MVDDLBX: u32 = 12u32;
pub const DTCT_MVLISTBOX: u32 = 11u32;
pub const DTCT_PAGE: u32 = 8u32;
pub const DTCT_RADIOBUTTON: u32 = 9u32;
pub const DTE_FLAG_ACL_CAPABLE: u32 = 1073741824u32;
pub const DTE_FLAG_REMOTE_VALID: u32 = 2147483648u32;
pub const DTE_MASK_LOCAL: u32 = 255u32;
pub const DTE_MASK_REMOTE: u32 = 65280u32;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct DTPAGE {
    pub cctl: u32,
    pub lpszResourceName: *mut i8,
    pub Anonymous: DTPAGE_0,
    pub lpctl: *mut DTCTL,
}
impl Default for DTPAGE {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union DTPAGE_0 {
    pub lpszComponent: *mut i8,
    pub ulItemID: u32,
}
impl Default for DTPAGE_0 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const DT_ACCEPT_DBCS: u32 = 32u32;
pub const DT_AGENT: u32 = 3u32;
pub const DT_DISTLIST: u32 = 1u32;
pub const DT_EDITABLE: u32 = 2u32;
pub const DT_EQUIPMENT: u32 = 8u32;
pub const DT_FOLDER: u32 = 16777216u32;
pub const DT_FOLDER_LINK: u32 = 33554432u32;
pub const DT_FOLDER_SPECIAL: u32 = 67108864u32;
pub const DT_FORUM: u32 = 2u32;
pub const DT_GLOBAL: u32 = 131072u32;
pub const DT_LOCAL: u32 = 196608u32;
pub const DT_MAILUSER: u32 = 0u32;
pub const DT_MODIFIABLE: u32 = 65536u32;
pub const DT_MULTILINE: u32 = 1u32;
pub const DT_NOT_SPECIFIC: u32 = 327680u32;
pub const DT_ORGANIZATION: u32 = 4u32;
pub const DT_PASSWORD_EDIT: u32 = 16u32;
pub const DT_PRIVATE_DISTLIST: u32 = 5u32;
pub const DT_REMOTE_MAILUSER: u32 = 6u32;
pub const DT_REQUIRED: u32 = 4u32;
pub const DT_ROOM: u32 = 7u32;
pub const DT_SEC_DISTLIST: u32 = 9u32;
pub const DT_SET_IMMEDIATE: u32 = 8u32;
pub const DT_SET_SELECTION: u32 = 64u32;
pub const DT_WAN: u32 = 262144u32;
pub const EBF_COMMITIFDIRTY: u32 = 131072u32;
pub const EBF_MASK: u32 = 4294901760u32;
pub const EBF_RECURSE: u32 = 65536u32;
pub const EDITOR_FORMAT_DONTKNOW: u32 = 0u32;
pub const EDITOR_FORMAT_HTML: u32 = 2u32;
pub const EDITOR_FORMAT_PLAINTEXT: u32 = 1u32;
pub const EDITOR_FORMAT_RTF: u32 = 3u32;
pub const EDK_RULES_VERSION: u32 = 1u32;
pub const EMS_AB_ADDRESS_LOOKUP: u32 = 1u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct ENCODINGTYPE(pub i32);
pub const END_DONT_RESEND: u32 = 262144u32;
pub const END_RESEND_LATER: u32 = 131072u32;
pub const END_RESEND_NOW: u32 = 65536u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ENTRYID {
    pub abFlags: [u8; 4],
    pub ab: [u8; 1],
}
impl Default for ENTRYID {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ENUMHEADERROW {
    pub hRow: *mut HHEADERROW__,
    pub pszHeader: windows_core::PSTR,
    pub pszData: windows_core::PSTR,
    pub cchData: u32,
    pub dwReserved: u32,
}
impl Default for ENUMHEADERROW {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ENUMPROPERTY {
    pub pszName: windows_core::PSTR,
    pub hRow: *mut HHEADERROW__,
    pub dwPropId: u32,
}
impl Default for ENUMPROPERTY {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const ENV_BLANK: u32 = 0u32;
pub const ENV_MSG_EXT: u32 = 2u32;
pub const ENV_RECIP_EXT: u32 = 4u32;
pub const ENV_RECIP_NUM: u32 = 1u32;
pub const EPF_NONAME: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ERROR_NOTIFICATION {
    pub cbEntryID: u32,
    pub lpEntryID: *mut ENTRYID,
    pub scode: i32,
    pub ulFlags: u32,
    pub lpMAPIError: *mut MAPIERROR,
}
impl Default for ERROR_NOTIFICATION {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const EXCHANGE_RM_SET_EXPLICIT_SD: u32 = 1u32;
pub const EXCHIVERB_FORWARD: u32 = 104u32;
pub const EXCHIVERB_OPEN: u32 = 0u32;
pub const EXCHIVERB_PRINT: u32 = 105u32;
pub const EXCHIVERB_REPLYTOALL: u32 = 103u32;
pub const EXCHIVERB_REPLYTOFOLDER: u32 = 108u32;
pub const EXCHIVERB_REPLYTOSENDER: u32 = 102u32;
pub const EXCHIVERB_RESERVED_COMPOSE: u32 = 100u32;
pub const EXCHIVERB_RESERVED_DELIVERY: u32 = 107u32;
pub const EXCHIVERB_RESERVED_OPEN: u32 = 101u32;
pub const EXCHIVERB_SAVEAS: u32 = 106u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct EXTENDED_NOTIFICATION {
    pub ulEvent: u32,
    pub cb: u32,
    pub pbEventParameters: *mut u8,
}
impl Default for EXTENDED_NOTIFICATION {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const E_ACCT_NOT_FOUND: u32 = 2148303105u32;
pub const E_ACCT_WRONG_SORT_ORDER: u32 = 2148303109u32;
pub const E_OLK_ALREADY_INITIALIZED: u32 = 2148302850u32;
pub const E_OLK_NOT_INITIALIZED: u32 = 2148302853u32;
pub const E_OLK_PARAM_NOT_SUPPORTED: u32 = 2148302851u32;
pub const E_OLK_PROP_READ_ONLY: u32 = 2148302861u32;
pub const E_OLK_REGISTRY: u32 = 2148302850u32;
pub const FACILITY_INTERNET: u32 = 12u32;
pub type FGETCOMPONENTPATH = Option<
    unsafe extern "system" fn(
        szcomponent: *mut i8,
        szqualifier: *mut i8,
        szdllpath: *mut i8,
        cchbuffersize: u32,
        finstall: windows_core::BOOL,
    ) -> windows_core::BOOL,
>;
pub const FILE_ATTRIBUTE_ARCHIVE: u32 = 32u32;
pub const FILE_ATTRIBUTE_DIRECTORY: u32 = 16u32;
pub const FILE_ATTRIBUTE_HIDDEN: u32 = 2u32;
pub const FILE_ATTRIBUTE_NORMAL: u32 = 128u32;
pub const FILE_ATTRIBUTE_READONLY: u32 = 1u32;
pub const FILE_ATTRIBUTE_SYSTEM: u32 = 4u32;
pub const FILE_ATTRIBUTE_TEMPORARY: u32 = 256u32;
pub const FILE_FLAG_RANDOM_ACCESS: u32 = 268435456u32;
pub const FILE_FLAG_SEQUENTIAL_SCAN: u32 = 134217728u32;
pub const FILE_FLAG_WRITE_THROUGH: u32 = 2147483648u32;
pub const FILL_ENTRY: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FINDBODY {
    pub pszPriType: windows_core::PSTR,
    pub pszSubType: windows_core::PSTR,
    pub dwReserved: u32,
}
impl Default for FINDBODY {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FINDHEADER {
    pub pszHeader: windows_core::PCSTR,
    pub dwReserved: u32,
}
impl Default for FINDHEADER {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FLATENTRY {
    pub cb: u32,
    pub abEntry: [u8; 1],
}
impl Default for FLATENTRY {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FLATENTRYLIST {
    pub cEntries: u32,
    pub cbEntries: u32,
    pub abEntries: [u8; 1],
}
impl Default for FLATENTRYLIST {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FLATMTSIDLIST {
    pub cMTSIDs: u32,
    pub cbMTSIDs: u32,
    pub abMTSIDs: [u8; 1],
}
impl Default for FLATMTSIDLIST {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const FLDSTATUS_DELMARKED: u32 = 8u32;
pub const FLDSTATUS_HIDDEN: u32 = 4u32;
pub const FLDSTATUS_HIGHLIGHTED: u32 = 1u32;
pub const FLDSTATUS_TAGGED: u32 = 2u32;
pub const FLUSH_ASYNC_OK: u32 = 32u32;
pub const FLUSH_DOWNLOAD: u32 = 4u32;
pub const FLUSH_FORCE: u32 = 8u32;
pub const FLUSH_NO_UI: u32 = 16u32;
pub const FLUSH_UPLOAD: u32 = 2u32;
pub const FL_FULLSTRING: u32 = 0u32;
pub const FL_IGNORECASE: u32 = 65536u32;
pub const FL_IGNORENONSPACE: u32 = 131072u32;
pub const FL_LOOSE: u32 = 262144u32;
pub const FL_PREFIX: u32 = 2u32;
pub const FL_SUBSTRING: u32 = 1u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct FNTSYSTYPE(pub i32);
pub const FNT_SYS_ICON: FNTSYSTYPE = FNTSYSTYPE(0i32);
pub const FNT_SYS_ICON_BOLD: FNTSYSTYPE = FNTSYSTYPE(1i32);
pub const FNT_SYS_ICON_STRIKEOUT: FNTSYSTYPE = FNTSYSTYPE(3i32);
pub const FNT_SYS_LAST: FNTSYSTYPE = FNTSYSTYPE(4i32);
pub const FNT_SYS_MENU: FNTSYSTYPE = FNTSYSTYPE(2i32);
pub const FOLDER_COMMON_VIEWS_VALID: u32 = 64u32;
pub const FOLDER_DIALOG: u32 = 2u32;
pub const FOLDER_FINDER_VALID: u32 = 128u32;
pub const FOLDER_GENERIC: u32 = 1u32;
pub const FOLDER_IPM_INBOX_VALID: u32 = 2u32;
pub const FOLDER_IPM_OUTBOX_VALID: u32 = 4u32;
pub const FOLDER_IPM_SENTMAIL_VALID: u32 = 16u32;
pub const FOLDER_IPM_SUBTREE_VALID: u32 = 1u32;
pub const FOLDER_IPM_WASTEBASKET_VALID: u32 = 8u32;
pub const FOLDER_MOVE: u32 = 1u32;
pub const FOLDER_ROOT: u32 = 0u32;
pub const FOLDER_SEARCH: u32 = 2u32;
pub const FOLDER_VIEWS_VALID: u32 = 32u32;
pub const FORCE_SAVE: u32 = 4u32;
pub const FORCE_SUBMIT: u32 = 1u32;
pub const FORCE_XP_CONNECT: u32 = 262144u32;
pub const FORCE_XP_DISCONNECT: u32 = 524288u32;
pub const FOREGROUND_SEARCH: u32 = 16u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FORMPRINTSETUP {
    pub ulFlags: u32,
    pub hDevMode: windows::Win32::Foundation::HGLOBAL,
    pub hDevNames: windows::Win32::Foundation::HGLOBAL,
    pub ulFirstPageNumber: u32,
    pub fPrintAttachments: u32,
}
impl Default for FORMPRINTSETUP {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const FORMPROPSET_INTERSECTION: u32 = 1u32;
pub const FORMPROPSET_UNION: u32 = 0u32;
pub const FPST_ENUM_PROP: u32 = 1u32;
pub const FPST_VANILLA: u32 = 0u32;
pub const FWD_AS_ATTACHMENT: u32 = 4u32;
pub const FWD_DO_NOT_MUNGE_MSG: u32 = 2u32;
pub const FWD_PRESERVE_SENDER: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FlagList {
    pub cFlags: u32,
    pub ulFlag: [u32; 1],
}
impl Default for FlagList {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const GENERATE_RECEIPT_ONLY: u32 = 16u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct HADDRESS__ {
    pub unused: u32,
}
impl Default for HADDRESS__ {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct HBODY__ {
    pub unused: u32,
}
impl Default for HBODY__ {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct HCHARSET__ {
    pub unused: u32,
}
impl Default for HCHARSET__ {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct HEADERROWINFO {
    pub dwRowNumber: u32,
    pub cboffStart: u32,
    pub cboffColon: u32,
    pub cboffEnd: u32,
}
impl Default for HEADERROWINFO {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct HEADERTABLEFLAGS(pub i32);
pub const HFRMREG_DEFAULT: u32 = 0u32;
pub const HFRMREG_FOLDER: u32 = 3u32;
pub const HFRMREG_LOCAL: u32 = 1u32;
pub const HFRMREG_PERSONAL: u32 = 2u32;
pub const HF_NO_DUPLICATES: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct HHEADERROW__ {
    pub unused: u32,
}
impl Default for HHEADERROW__ {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const HOOK_CANCEL: u32 = 2u32;
pub const HOOK_DELETE: u32 = 1u32;
pub const HOOK_INBOUND: u32 = 512u32;
pub const HOOK_OUTBOUND: u32 = 1024u32;
pub type HPPROVIDERINIT = Option<
    unsafe extern "system" fn(
        lpsession: windows_core::Ref<'_, IMAPISession>,
        hinstance: windows::Win32::Foundation::HINSTANCE,
        lpallocatebuffer: LPALLOCATEBUFFER,
        lpallocatemore: LPALLOCATEMORE,
        lpfreebuffer: LPFREEBUFFER,
        lpsectionuid: *mut MAPIUID,
        ulflags: u32,
        lppspoolerhook: windows_core::OutRef<'_, ISpoolerHook>,
    ) -> windows_core::HRESULT,
>;
pub const HTF_ENUMHANDLESONLY: HEADERTABLEFLAGS = HEADERTABLEFLAGS(2i32);
pub const HTF_NAMEINDATA: HEADERTABLEFLAGS = HEADERTABLEFLAGS(1i32);
windows_core::imp::define_interface!(
    IABContainer,
    IABContainer_Vtbl,
    0x0002030d_0000_0000_c000_000000000046
);
impl core::ops::Deref for IABContainer {
    type Target = IMAPIContainer;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IABContainer,
    windows_core::IUnknown,
    IMAPIProp,
    IMAPIContainer
);
impl IABContainer {
    pub unsafe fn CreateEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulcreateflags: u32,
        lppmapipropentry: *mut Option<IMAPIProp>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CreateEntry)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                ulcreateflags,
                core::mem::transmute(lppmapipropentry),
            )
            .ok()
        }
    }
    pub unsafe fn CopyEntries<P2>(
        &self,
        lpentries: *mut SBinaryArray,
        uluiparam: usize,
        lpprogress: P2,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CopyEntries)(
                windows_core::Interface::as_raw(self),
                lpentries as _,
                uluiparam,
                lpprogress.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn DeleteEntries(
        &self,
        lpentries: *mut SBinaryArray,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteEntries)(
                windows_core::Interface::as_raw(self),
                lpentries as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn ResolveNames(
        &self,
        lpproptagarray: *mut SPropTagArray,
        ulflags: u32,
        lpadrlist: *mut ADRLIST,
        lpflaglist: *mut FlagList,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ResolveNames)(
                windows_core::Interface::as_raw(self),
                lpproptagarray as _,
                ulflags,
                lpadrlist as _,
                lpflaglist as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IABContainer_Vtbl {
    pub base__: IMAPIContainer_Vtbl,
    pub CreateEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CopyEntries: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SBinaryArray,
        usize,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub DeleteEntries: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SBinaryArray,
        u32,
    ) -> windows_core::HRESULT,
    pub ResolveNames: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SPropTagArray,
        u32,
        *mut ADRLIST,
        *mut FlagList,
    ) -> windows_core::HRESULT,
}
pub trait IABContainer_Impl: IMAPIContainer_Impl {
    fn CreateEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulcreateflags: u32,
        lppmapipropentry: windows_core::OutRef<'_, IMAPIProp>,
    ) -> windows_core::Result<()>;
    fn CopyEntries(
        &self,
        lpentries: *mut SBinaryArray,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn DeleteEntries(&self, lpentries: *mut SBinaryArray, ulflags: u32)
        -> windows_core::Result<()>;
    fn ResolveNames(
        &self,
        lpproptagarray: *mut SPropTagArray,
        ulflags: u32,
        lpadrlist: *mut ADRLIST,
        lpflaglist: *mut FlagList,
    ) -> windows_core::Result<()>;
}
impl IABContainer_Vtbl {
    pub const fn new<Identity: IABContainer_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn CreateEntry<Identity: IABContainer_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            ulcreateflags: u32,
            lppmapipropentry: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABContainer_Impl::CreateEntry(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&ulcreateflags),
                    core::mem::transmute_copy(&lppmapipropentry),
                )
                .into()
            }
        }
        unsafe extern "system" fn CopyEntries<Identity: IABContainer_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpentries: *mut SBinaryArray,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABContainer_Impl::CopyEntries(
                    this,
                    core::mem::transmute_copy(&lpentries),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteEntries<
            Identity: IABContainer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpentries: *mut SBinaryArray,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABContainer_Impl::DeleteEntries(
                    this,
                    core::mem::transmute_copy(&lpentries),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn ResolveNames<Identity: IABContainer_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpproptagarray: *mut SPropTagArray,
            ulflags: u32,
            lpadrlist: *mut ADRLIST,
            lpflaglist: *mut FlagList,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABContainer_Impl::ResolveNames(
                    this,
                    core::mem::transmute_copy(&lpproptagarray),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpadrlist),
                    core::mem::transmute_copy(&lpflaglist),
                )
                .into()
            }
        }
        Self {
            base__: IMAPIContainer_Vtbl::new::<Identity, OFFSET>(),
            CreateEntry: CreateEntry::<Identity, OFFSET>,
            CopyEntries: CopyEntries::<Identity, OFFSET>,
            DeleteEntries: DeleteEntries::<Identity, OFFSET>,
            ResolveNames: ResolveNames::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IABContainer as windows_core::Interface>::IID
            || iid == &<IMAPIProp as windows_core::Interface>::IID
            || iid == &<IMAPIContainer as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IABContainer {}
pub const IABContainer_CopyEntries: METHODS = METHODS(43i32);
pub const IABContainer_CreateEntry: METHODS = METHODS(42i32);
pub const IABContainer_DeleteEntries: METHODS = METHODS(44i32);
pub const IABContainer_ResolveNames: METHODS = METHODS(45i32);
windows_core::imp::define_interface!(
    IABLogon,
    IABLogon_Vtbl,
    0x00020314_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IABLogon, windows_core::IUnknown);
impl IABLogon {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn Logoff(&self, ulflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Logoff)(
                windows_core::Interface::as_raw(self),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppunk: *mut Option<windows_core::IUnknown>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenEntry)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                lpinterface as _,
                ulflags,
                lpulobjtype as _,
                core::mem::transmute(lppunk),
            )
            .ok()
        }
    }
    pub unsafe fn CompareEntryIDs(
        &self,
        cbentryid1: u32,
        lpentryid1: *mut ENTRYID,
        cbentryid2: u32,
        lpentryid2: *mut ENTRYID,
        ulflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CompareEntryIDs)(
                windows_core::Interface::as_raw(self),
                cbentryid1,
                lpentryid1 as _,
                cbentryid2,
                lpentryid2 as _,
                ulflags,
                lpulresult as _,
            )
            .ok()
        }
    }
    pub unsafe fn Advise<P3>(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        uleventmask: u32,
        lpadvisesink: P3,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<IMAPIAdviseSink>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Advise)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                uleventmask,
                lpadvisesink.param().abi(),
                lpulconnection as _,
            )
            .ok()
        }
    }
    pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Unadvise)(
                windows_core::Interface::as_raw(self),
                ulconnection,
            )
            .ok()
        }
    }
    pub unsafe fn OpenStatusEntry(
        &self,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppentry: *mut Option<IMAPIStatus>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenStatusEntry)(
                windows_core::Interface::as_raw(self),
                lpinterface as _,
                ulflags,
                lpulobjtype as _,
                core::mem::transmute(lppentry),
            )
            .ok()
        }
    }
    pub unsafe fn OpenTemplateID<P3, P6>(
        &self,
        cbtemplateid: u32,
        lptemplateid: *mut ENTRYID,
        ultemplateflags: u32,
        lpmapipropdata: P3,
        lpinterface: *mut windows_core::GUID,
        lppmapipropnew: *mut Option<IMAPIProp>,
        lpmapipropsibling: P6,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<IMAPIProp>,
        P6: windows_core::Param<IMAPIProp>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).OpenTemplateID)(
                windows_core::Interface::as_raw(self),
                cbtemplateid,
                lptemplateid as _,
                ultemplateflags,
                lpmapipropdata.param().abi(),
                lpinterface as _,
                core::mem::transmute(lppmapipropnew),
                lpmapipropsibling.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn GetOneOffTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetOneOffTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn PrepareRecips(
        &self,
        ulflags: u32,
        lpproptagarray: *mut SPropTagArray,
        lpreciplist: *mut ADRLIST,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PrepareRecips)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpproptagarray as _,
                lpreciplist as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IABLogon_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub Logoff: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub OpenEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        *mut windows_core::GUID,
        u32,
        *mut u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CompareEntryIDs: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut ENTRYID,
        u32,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub Advise: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut core::ffi::c_void,
        *mut usize,
    ) -> windows_core::HRESULT,
    pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
    pub OpenStatusEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        u32,
        *mut u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub OpenTemplateID: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        *mut *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetOneOffTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub PrepareRecips: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut SPropTagArray,
        *mut ADRLIST,
    ) -> windows_core::HRESULT,
}
pub trait IABLogon_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn Logoff(&self, ulflags: u32) -> windows_core::Result<()>;
    fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
    ) -> windows_core::Result<()>;
    fn CompareEntryIDs(
        &self,
        cbentryid1: u32,
        lpentryid1: *mut ENTRYID,
        cbentryid2: u32,
        lpentryid2: *mut ENTRYID,
        ulflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()>;
    fn Advise(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        uleventmask: u32,
        lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>;
    fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
    fn OpenStatusEntry(
        &self,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppentry: windows_core::OutRef<'_, IMAPIStatus>,
    ) -> windows_core::Result<()>;
    fn OpenTemplateID(
        &self,
        cbtemplateid: u32,
        lptemplateid: *mut ENTRYID,
        ultemplateflags: u32,
        lpmapipropdata: windows_core::Ref<'_, IMAPIProp>,
        lpinterface: *mut windows_core::GUID,
        lppmapipropnew: windows_core::OutRef<'_, IMAPIProp>,
        lpmapipropsibling: windows_core::Ref<'_, IMAPIProp>,
    ) -> windows_core::Result<()>;
    fn GetOneOffTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn PrepareRecips(
        &self,
        ulflags: u32,
        lpproptagarray: *mut SPropTagArray,
        lpreciplist: *mut ADRLIST,
    ) -> windows_core::Result<()>;
}
impl IABLogon_Vtbl {
    pub const fn new<Identity: IABLogon_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<Identity: IABLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABLogon_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn Logoff<Identity: IABLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABLogon_Impl::Logoff(this, core::mem::transmute_copy(&ulflags)).into()
            }
        }
        unsafe extern "system" fn OpenEntry<Identity: IABLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lpulobjtype: *mut u32,
            lppunk: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABLogon_Impl::OpenEntry(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulobjtype),
                    core::mem::transmute_copy(&lppunk),
                )
                .into()
            }
        }
        unsafe extern "system" fn CompareEntryIDs<Identity: IABLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid1: u32,
            lpentryid1: *mut ENTRYID,
            cbentryid2: u32,
            lpentryid2: *mut ENTRYID,
            ulflags: u32,
            lpulresult: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABLogon_Impl::CompareEntryIDs(
                    this,
                    core::mem::transmute_copy(&cbentryid1),
                    core::mem::transmute_copy(&lpentryid1),
                    core::mem::transmute_copy(&cbentryid2),
                    core::mem::transmute_copy(&lpentryid2),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulresult),
                )
                .into()
            }
        }
        unsafe extern "system" fn Advise<Identity: IABLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            uleventmask: u32,
            lpadvisesink: *mut core::ffi::c_void,
            lpulconnection: *mut usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABLogon_Impl::Advise(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&uleventmask),
                    core::mem::transmute_copy(&lpadvisesink),
                    core::mem::transmute_copy(&lpulconnection),
                )
                .into()
            }
        }
        unsafe extern "system" fn Unadvise<Identity: IABLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulconnection: usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABLogon_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
            }
        }
        unsafe extern "system" fn OpenStatusEntry<Identity: IABLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lpulobjtype: *mut u32,
            lppentry: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABLogon_Impl::OpenStatusEntry(
                    this,
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulobjtype),
                    core::mem::transmute_copy(&lppentry),
                )
                .into()
            }
        }
        unsafe extern "system" fn OpenTemplateID<Identity: IABLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbtemplateid: u32,
            lptemplateid: *mut ENTRYID,
            ultemplateflags: u32,
            lpmapipropdata: *mut core::ffi::c_void,
            lpinterface: *mut windows_core::GUID,
            lppmapipropnew: *mut *mut core::ffi::c_void,
            lpmapipropsibling: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABLogon_Impl::OpenTemplateID(
                    this,
                    core::mem::transmute_copy(&cbtemplateid),
                    core::mem::transmute_copy(&lptemplateid),
                    core::mem::transmute_copy(&ultemplateflags),
                    core::mem::transmute_copy(&lpmapipropdata),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&lppmapipropnew),
                    core::mem::transmute_copy(&lpmapipropsibling),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetOneOffTable<Identity: IABLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IABLogon_Impl::GetOneOffTable(this, core::mem::transmute_copy(&ulflags)) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn PrepareRecips<Identity: IABLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpproptagarray: *mut SPropTagArray,
            lpreciplist: *mut ADRLIST,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABLogon_Impl::PrepareRecips(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpproptagarray),
                    core::mem::transmute_copy(&lpreciplist),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            Logoff: Logoff::<Identity, OFFSET>,
            OpenEntry: OpenEntry::<Identity, OFFSET>,
            CompareEntryIDs: CompareEntryIDs::<Identity, OFFSET>,
            Advise: Advise::<Identity, OFFSET>,
            Unadvise: Unadvise::<Identity, OFFSET>,
            OpenStatusEntry: OpenStatusEntry::<Identity, OFFSET>,
            OpenTemplateID: OpenTemplateID::<Identity, OFFSET>,
            GetOneOffTable: GetOneOffTable::<Identity, OFFSET>,
            PrepareRecips: PrepareRecips::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IABLogon as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IABLogon {}
pub const IABLogon_Advise: METHODS = METHODS(88i32);
pub const IABLogon_CompareEntryIDs: METHODS = METHODS(87i32);
pub const IABLogon_GetLastError: METHODS = METHODS(84i32);
pub const IABLogon_GetOneOffTable: METHODS = METHODS(92i32);
pub const IABLogon_Logoff: METHODS = METHODS(85i32);
pub const IABLogon_OpenEntry: METHODS = METHODS(86i32);
pub const IABLogon_OpenStatusEntry: METHODS = METHODS(90i32);
pub const IABLogon_OpenTemplateID: METHODS = METHODS(91i32);
pub const IABLogon_PrepareRecips: METHODS = METHODS(93i32);
pub const IABLogon_Unadvise: METHODS = METHODS(89i32);
windows_core::imp::define_interface!(
    IABProvider,
    IABProvider_Vtbl,
    0x00020311_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IABProvider, windows_core::IUnknown);
impl IABProvider {
    pub unsafe fn Shutdown(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Shutdown)(
                windows_core::Interface::as_raw(self),
                lpulflags as _,
            )
            .ok()
        }
    }
    pub unsafe fn Logon<P0>(
        &self,
        lpmapisup: P0,
        uluiparam: usize,
        lpszprofilename: *mut i8,
        ulflags: u32,
        lpulpcbsecurity: *mut u32,
        lppbsecurity: *mut *mut u8,
        lppmapierror: *mut *mut MAPIERROR,
        lppablogon: *mut Option<IABLogon>,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMAPISupport>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Logon)(
                windows_core::Interface::as_raw(self),
                lpmapisup.param().abi(),
                uluiparam,
                lpszprofilename as _,
                ulflags,
                lpulpcbsecurity as _,
                lppbsecurity as _,
                lppmapierror as _,
                core::mem::transmute(lppablogon),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IABProvider_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Shutdown:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub Logon: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        usize,
        *mut i8,
        u32,
        *mut u32,
        *mut *mut u8,
        *mut *mut MAPIERROR,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IABProvider_Impl: windows_core::IUnknownImpl {
    fn Shutdown(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
    fn Logon(
        &self,
        lpmapisup: windows_core::Ref<'_, IMAPISupport>,
        uluiparam: usize,
        lpszprofilename: *mut i8,
        ulflags: u32,
        lpulpcbsecurity: *mut u32,
        lppbsecurity: *mut *mut u8,
        lppmapierror: *mut *mut MAPIERROR,
        lppablogon: windows_core::OutRef<'_, IABLogon>,
    ) -> windows_core::Result<()>;
}
impl IABProvider_Vtbl {
    pub const fn new<Identity: IABProvider_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Shutdown<Identity: IABProvider_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulflags: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABProvider_Impl::Shutdown(this, core::mem::transmute_copy(&lpulflags)).into()
            }
        }
        unsafe extern "system" fn Logon<Identity: IABProvider_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpmapisup: *mut core::ffi::c_void,
            uluiparam: usize,
            lpszprofilename: *mut i8,
            ulflags: u32,
            lpulpcbsecurity: *mut u32,
            lppbsecurity: *mut *mut u8,
            lppmapierror: *mut *mut MAPIERROR,
            lppablogon: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IABProvider_Impl::Logon(
                    this,
                    core::mem::transmute_copy(&lpmapisup),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpszprofilename),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulpcbsecurity),
                    core::mem::transmute_copy(&lppbsecurity),
                    core::mem::transmute_copy(&lppmapierror),
                    core::mem::transmute_copy(&lppablogon),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Shutdown: Shutdown::<Identity, OFFSET>,
            Logon: Logon::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IABProvider as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IABProvider {}
pub const IABProvider_Logon: METHODS = METHODS(83i32);
pub const IABProvider_Shutdown: METHODS = METHODS(82i32);
pub const IAP_ADRTYPE: u32 = 4u32;
pub const IAP_ALL: u32 = 4294967295u32;
pub const IAP_CERTSTATE: u32 = 256u32;
pub const IAP_CHARSET: u32 = 1u32;
pub const IAP_COOKIE: u32 = 4096u32;
pub const IAP_EMAIL: u32 = 32u32;
pub const IAP_ENCODING: u32 = 2048u32;
pub const IAP_ENCRYPTION_PRINT: u32 = 1024u32;
pub const IAP_FRIENDLY: u32 = 8u32;
pub const IAP_HANDLE: u32 = 2u32;
pub const IAP_SIGNING_PRINT: u32 = 512u32;
pub const IAT_ALL: u32 = 4294967295u32;
pub const IAT_APPARTO: u32 = 512u32;
pub const IAT_BCC: u32 = 16u32;
pub const IAT_CC: u32 = 8u32;
pub const IAT_FROM: u32 = 1u32;
pub const IAT_REPLYTO: u32 = 32u32;
pub const IAT_RETRCPTTO: u32 = 128u32;
pub const IAT_RETURNPATH: u32 = 64u32;
pub const IAT_RR: u32 = 256u32;
pub const IAT_SENDER: u32 = 2u32;
pub const IAT_TO: u32 = 4u32;
pub const IAT_UNKNOWN: u32 = 0u32;
windows_core::imp::define_interface!(
    IAddrBook,
    IAddrBook_Vtbl,
    0x00020309_0000_0000_c000_000000000046
);
impl core::ops::Deref for IAddrBook {
    type Target = IMAPIProp;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(IAddrBook, windows_core::IUnknown, IMAPIProp);
impl IAddrBook {
    pub unsafe fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppunk: *mut Option<windows_core::IUnknown>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenEntry)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                lpinterface as _,
                ulflags,
                lpulobjtype as _,
                core::mem::transmute(lppunk),
            )
            .ok()
        }
    }
    pub unsafe fn CompareEntryIDs(
        &self,
        cbentryid1: u32,
        lpentryid1: *mut ENTRYID,
        cbentryid2: u32,
        lpentryid2: *mut ENTRYID,
        ulflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CompareEntryIDs)(
                windows_core::Interface::as_raw(self),
                cbentryid1,
                lpentryid1 as _,
                cbentryid2,
                lpentryid2 as _,
                ulflags,
                lpulresult as _,
            )
            .ok()
        }
    }
    pub unsafe fn Advise<P3>(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        uleventmask: u32,
        lpadvisesink: P3,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<IMAPIAdviseSink>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Advise)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                uleventmask,
                lpadvisesink.param().abi(),
                lpulconnection as _,
            )
            .ok()
        }
    }
    pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Unadvise)(
                windows_core::Interface::as_raw(self),
                ulconnection,
            )
            .ok()
        }
    }
    pub unsafe fn CreateOneOff(
        &self,
        lpszname: *mut i8,
        lpszadrtype: *mut i8,
        lpszaddress: *mut i8,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CreateOneOff)(
                windows_core::Interface::as_raw(self),
                lpszname as _,
                lpszadrtype as _,
                lpszaddress as _,
                ulflags,
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn NewEntry(
        &self,
        uluiparam: usize,
        ulflags: u32,
        cbeidcontainer: u32,
        lpeidcontainer: *mut ENTRYID,
        cbeidnewentrytpl: u32,
        lpeidnewentrytpl: *mut ENTRYID,
        lpcbeidnewentry: *mut u32,
        lppeidnewentry: *mut *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).NewEntry)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                cbeidcontainer,
                lpeidcontainer as _,
                cbeidnewentrytpl,
                lpeidnewentrytpl as _,
                lpcbeidnewentry as _,
                lppeidnewentry as _,
            )
            .ok()
        }
    }
    pub unsafe fn ResolveName(
        &self,
        uluiparam: usize,
        ulflags: u32,
        lpsznewentrytitle: *mut i8,
        lpadrlist: *mut ADRLIST,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ResolveName)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                lpsznewentrytitle as _,
                lpadrlist as _,
            )
            .ok()
        }
    }
    pub unsafe fn Address(
        &self,
        lpuluiparam: *mut usize,
        lpadrparms: *mut ADRPARM,
        lppadrlist: *mut *mut ADRLIST,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Address)(
                windows_core::Interface::as_raw(self),
                lpuluiparam as _,
                lpadrparms as _,
                lppadrlist as _,
            )
            .ok()
        }
    }
    pub unsafe fn Details(
        &self,
        lpuluiparam: *mut usize,
        lpfndismiss: LPFNDISMISS,
        lpvdismisscontext: *mut core::ffi::c_void,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
        lpvbuttoncontext: *mut core::ffi::c_void,
        lpszbuttontext: *mut i8,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Details)(
                windows_core::Interface::as_raw(self),
                lpuluiparam as _,
                lpfndismiss,
                lpvdismisscontext as _,
                cbentryid,
                lpentryid as _,
                lpfbuttoncallback,
                lpvbuttoncontext as _,
                lpszbuttontext as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn RecipOptions(
        &self,
        uluiparam: usize,
        ulflags: u32,
        lprecip: *mut ADRENTRY,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).RecipOptions)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                lprecip as _,
            )
            .ok()
        }
    }
    pub unsafe fn QueryDefaultRecipOpt(
        &self,
        lpszadrtype: *mut i8,
        ulflags: u32,
        lpcvalues: *mut u32,
        lppoptions: *mut *mut SPropValue,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).QueryDefaultRecipOpt)(
                windows_core::Interface::as_raw(self),
                lpszadrtype as _,
                ulflags,
                lpcvalues as _,
                lppoptions as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetPAB(
        &self,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetPAB)(
                windows_core::Interface::as_raw(self),
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetPAB(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetPAB)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetDefaultDir(
        &self,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetDefaultDir)(
                windows_core::Interface::as_raw(self),
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetDefaultDir(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetDefaultDir)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetSearchPath(
        &self,
        ulflags: u32,
        lppsearchpath: *mut *mut SRowSet,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetSearchPath)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lppsearchpath as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetSearchPath(
        &self,
        ulflags: u32,
        lpsearchpath: *mut SRowSet,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetSearchPath)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpsearchpath as _,
            )
            .ok()
        }
    }
    pub unsafe fn PrepareRecips(
        &self,
        ulflags: u32,
        lpproptagarray: *mut SPropTagArray,
        lpreciplist: *mut ADRLIST,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PrepareRecips)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpproptagarray as _,
                lpreciplist as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IAddrBook_Vtbl {
    pub base__: IMAPIProp_Vtbl,
    pub OpenEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        *mut windows_core::GUID,
        u32,
        *mut u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CompareEntryIDs: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut ENTRYID,
        u32,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub Advise: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut core::ffi::c_void,
        *mut usize,
    ) -> windows_core::HRESULT,
    pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
    pub CreateOneOff: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        *mut i8,
        *mut i8,
        u32,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub NewEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        u32,
        *mut ENTRYID,
        u32,
        *mut ENTRYID,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub ResolveName: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut i8,
        *mut ADRLIST,
    ) -> windows_core::HRESULT,
    pub Address: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut usize,
        *mut ADRPARM,
        *mut *mut ADRLIST,
    ) -> windows_core::HRESULT,
    pub Details: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut usize,
        LPFNDISMISS,
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        windows::Win32::System::AddressBook::LPFNBUTTON,
        *mut core::ffi::c_void,
        *mut i8,
        u32,
    ) -> windows_core::HRESULT,
    pub RecipOptions: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut ADRENTRY,
    ) -> windows_core::HRESULT,
    pub QueryDefaultRecipOpt: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        u32,
        *mut u32,
        *mut *mut SPropValue,
    ) -> windows_core::HRESULT,
    pub GetPAB: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub SetPAB: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub GetDefaultDir: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub SetDefaultDir: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub GetSearchPath: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut SRowSet,
    ) -> windows_core::HRESULT,
    pub SetSearchPath: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut SRowSet,
    ) -> windows_core::HRESULT,
    pub PrepareRecips: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut SPropTagArray,
        *mut ADRLIST,
    ) -> windows_core::HRESULT,
}
pub trait IAddrBook_Impl: IMAPIProp_Impl {
    fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
    ) -> windows_core::Result<()>;
    fn CompareEntryIDs(
        &self,
        cbentryid1: u32,
        lpentryid1: *mut ENTRYID,
        cbentryid2: u32,
        lpentryid2: *mut ENTRYID,
        ulflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()>;
    fn Advise(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        uleventmask: u32,
        lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>;
    fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
    fn CreateOneOff(
        &self,
        lpszname: *mut i8,
        lpszadrtype: *mut i8,
        lpszaddress: *mut i8,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn NewEntry(
        &self,
        uluiparam: usize,
        ulflags: u32,
        cbeidcontainer: u32,
        lpeidcontainer: *mut ENTRYID,
        cbeidnewentrytpl: u32,
        lpeidnewentrytpl: *mut ENTRYID,
        lpcbeidnewentry: *mut u32,
        lppeidnewentry: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn ResolveName(
        &self,
        uluiparam: usize,
        ulflags: u32,
        lpsznewentrytitle: *mut i8,
        lpadrlist: *mut ADRLIST,
    ) -> windows_core::Result<()>;
    fn Address(
        &self,
        lpuluiparam: *mut usize,
        lpadrparms: *mut ADRPARM,
        lppadrlist: *mut *mut ADRLIST,
    ) -> windows_core::Result<()>;
    fn Details(
        &self,
        lpuluiparam: *mut usize,
        lpfndismiss: LPFNDISMISS,
        lpvdismisscontext: *mut core::ffi::c_void,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
        lpvbuttoncontext: *mut core::ffi::c_void,
        lpszbuttontext: *mut i8,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn RecipOptions(
        &self,
        uluiparam: usize,
        ulflags: u32,
        lprecip: *mut ADRENTRY,
    ) -> windows_core::Result<()>;
    fn QueryDefaultRecipOpt(
        &self,
        lpszadrtype: *mut i8,
        ulflags: u32,
        lpcvalues: *mut u32,
        lppoptions: *mut *mut SPropValue,
    ) -> windows_core::Result<()>;
    fn GetPAB(
        &self,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn SetPAB(&self, cbentryid: u32, lpentryid: *mut ENTRYID) -> windows_core::Result<()>;
    fn GetDefaultDir(
        &self,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn SetDefaultDir(&self, cbentryid: u32, lpentryid: *mut ENTRYID) -> windows_core::Result<()>;
    fn GetSearchPath(
        &self,
        ulflags: u32,
        lppsearchpath: *mut *mut SRowSet,
    ) -> windows_core::Result<()>;
    fn SetSearchPath(&self, ulflags: u32, lpsearchpath: *mut SRowSet) -> windows_core::Result<()>;
    fn PrepareRecips(
        &self,
        ulflags: u32,
        lpproptagarray: *mut SPropTagArray,
        lpreciplist: *mut ADRLIST,
    ) -> windows_core::Result<()>;
}
impl IAddrBook_Vtbl {
    pub const fn new<Identity: IAddrBook_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn OpenEntry<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lpulobjtype: *mut u32,
            lppunk: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::OpenEntry(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulobjtype),
                    core::mem::transmute_copy(&lppunk),
                )
                .into()
            }
        }
        unsafe extern "system" fn CompareEntryIDs<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid1: u32,
            lpentryid1: *mut ENTRYID,
            cbentryid2: u32,
            lpentryid2: *mut ENTRYID,
            ulflags: u32,
            lpulresult: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::CompareEntryIDs(
                    this,
                    core::mem::transmute_copy(&cbentryid1),
                    core::mem::transmute_copy(&lpentryid1),
                    core::mem::transmute_copy(&cbentryid2),
                    core::mem::transmute_copy(&lpentryid2),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulresult),
                )
                .into()
            }
        }
        unsafe extern "system" fn Advise<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            uleventmask: u32,
            lpadvisesink: *mut core::ffi::c_void,
            lpulconnection: *mut usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::Advise(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&uleventmask),
                    core::mem::transmute_copy(&lpadvisesink),
                    core::mem::transmute_copy(&lpulconnection),
                )
                .into()
            }
        }
        unsafe extern "system" fn Unadvise<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulconnection: usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
            }
        }
        unsafe extern "system" fn CreateOneOff<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpszname: *mut i8,
            lpszadrtype: *mut i8,
            lpszaddress: *mut i8,
            ulflags: u32,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::CreateOneOff(
                    this,
                    core::mem::transmute_copy(&lpszname),
                    core::mem::transmute_copy(&lpszadrtype),
                    core::mem::transmute_copy(&lpszaddress),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn NewEntry<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            cbeidcontainer: u32,
            lpeidcontainer: *mut ENTRYID,
            cbeidnewentrytpl: u32,
            lpeidnewentrytpl: *mut ENTRYID,
            lpcbeidnewentry: *mut u32,
            lppeidnewentry: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::NewEntry(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&cbeidcontainer),
                    core::mem::transmute_copy(&lpeidcontainer),
                    core::mem::transmute_copy(&cbeidnewentrytpl),
                    core::mem::transmute_copy(&lpeidnewentrytpl),
                    core::mem::transmute_copy(&lpcbeidnewentry),
                    core::mem::transmute_copy(&lppeidnewentry),
                )
                .into()
            }
        }
        unsafe extern "system" fn ResolveName<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            lpsznewentrytitle: *mut i8,
            lpadrlist: *mut ADRLIST,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::ResolveName(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpsznewentrytitle),
                    core::mem::transmute_copy(&lpadrlist),
                )
                .into()
            }
        }
        unsafe extern "system" fn Address<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpuluiparam: *mut usize,
            lpadrparms: *mut ADRPARM,
            lppadrlist: *mut *mut ADRLIST,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::Address(
                    this,
                    core::mem::transmute_copy(&lpuluiparam),
                    core::mem::transmute_copy(&lpadrparms),
                    core::mem::transmute_copy(&lppadrlist),
                )
                .into()
            }
        }
        unsafe extern "system" fn Details<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpuluiparam: *mut usize,
            lpfndismiss: LPFNDISMISS,
            lpvdismisscontext: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
            lpvbuttoncontext: *mut core::ffi::c_void,
            lpszbuttontext: *mut i8,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::Details(
                    this,
                    core::mem::transmute_copy(&lpuluiparam),
                    core::mem::transmute_copy(&lpfndismiss),
                    core::mem::transmute_copy(&lpvdismisscontext),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpfbuttoncallback),
                    core::mem::transmute_copy(&lpvbuttoncontext),
                    core::mem::transmute_copy(&lpszbuttontext),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn RecipOptions<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            lprecip: *mut ADRENTRY,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::RecipOptions(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lprecip),
                )
                .into()
            }
        }
        unsafe extern "system" fn QueryDefaultRecipOpt<
            Identity: IAddrBook_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszadrtype: *mut i8,
            ulflags: u32,
            lpcvalues: *mut u32,
            lppoptions: *mut *mut SPropValue,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::QueryDefaultRecipOpt(
                    this,
                    core::mem::transmute_copy(&lpszadrtype),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpcvalues),
                    core::mem::transmute_copy(&lppoptions),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetPAB<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::GetPAB(
                    this,
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetPAB<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::SetPAB(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetDefaultDir<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::GetDefaultDir(
                    this,
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetDefaultDir<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::SetDefaultDir(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetSearchPath<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lppsearchpath: *mut *mut SRowSet,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::GetSearchPath(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppsearchpath),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetSearchPath<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpsearchpath: *mut SRowSet,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::SetSearchPath(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpsearchpath),
                )
                .into()
            }
        }
        unsafe extern "system" fn PrepareRecips<Identity: IAddrBook_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpproptagarray: *mut SPropTagArray,
            lpreciplist: *mut ADRLIST,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IAddrBook_Impl::PrepareRecips(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpproptagarray),
                    core::mem::transmute_copy(&lpreciplist),
                )
                .into()
            }
        }
        Self {
            base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
            OpenEntry: OpenEntry::<Identity, OFFSET>,
            CompareEntryIDs: CompareEntryIDs::<Identity, OFFSET>,
            Advise: Advise::<Identity, OFFSET>,
            Unadvise: Unadvise::<Identity, OFFSET>,
            CreateOneOff: CreateOneOff::<Identity, OFFSET>,
            NewEntry: NewEntry::<Identity, OFFSET>,
            ResolveName: ResolveName::<Identity, OFFSET>,
            Address: Address::<Identity, OFFSET>,
            Details: Details::<Identity, OFFSET>,
            RecipOptions: RecipOptions::<Identity, OFFSET>,
            QueryDefaultRecipOpt: QueryDefaultRecipOpt::<Identity, OFFSET>,
            GetPAB: GetPAB::<Identity, OFFSET>,
            SetPAB: SetPAB::<Identity, OFFSET>,
            GetDefaultDir: GetDefaultDir::<Identity, OFFSET>,
            SetDefaultDir: SetDefaultDir::<Identity, OFFSET>,
            GetSearchPath: GetSearchPath::<Identity, OFFSET>,
            SetSearchPath: SetSearchPath::<Identity, OFFSET>,
            PrepareRecips: PrepareRecips::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IAddrBook as windows_core::Interface>::IID
            || iid == &<IMAPIProp as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IAddrBook {}
windows_core::imp::define_interface!(IAttach, IAttach_Vtbl, 0);
impl core::ops::Deref for IAttach {
    type Target = IMAPIProp;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(IAttach, windows_core::IUnknown, IMAPIProp);
#[repr(C)]
pub struct IAttach_Vtbl {
    pub base__: IMAPIProp_Vtbl,
}
pub trait IAttach_Impl: IMAPIProp_Impl {}
impl IAttach_Vtbl {
    pub const fn new<Identity: IAttach_Impl, const OFFSET: isize>() -> Self {
        Self {
            base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IAttach as windows_core::Interface>::IID
            || iid == &<IMAPIProp as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IAttach {}
pub const IBL_FIRST: BODYLOCATION = BODYLOCATION(2i32);
pub const IBL_LAST: BODYLOCATION = BODYLOCATION(3i32);
pub const IBL_NEXT: BODYLOCATION = BODYLOCATION(4i32);
pub const IBL_PARENT: BODYLOCATION = BODYLOCATION(1i32);
pub const IBL_PREVIOUS: BODYLOCATION = BODYLOCATION(5i32);
pub const IBL_ROOT: BODYLOCATION = BODYLOCATION(0i32);
pub const IBT_ATTACHMENT: IMSGBODYTYPE = IMSGBODYTYPE(1i32);
pub const IBT_AUTOATTACH: IMSGBODYTYPE = IMSGBODYTYPE(4i32);
pub const IBT_CSETTAGGED: IMSGBODYTYPE = IMSGBODYTYPE(3i32);
pub const IBT_EMPTY: IMSGBODYTYPE = IMSGBODYTYPE(2i32);
pub const IBT_SECURE: IMSGBODYTYPE = IMSGBODYTYPE(0i32);
pub const ICON_INDEX_ACCEPT: u32 = 1029u32;
pub const ICON_INDEX_ASSIGNEE_TASK: u32 = 1282u32;
pub const ICON_INDEX_ASSIGNER_TASK: u32 = 1283u32;
pub const ICON_INDEX_CANCELATION: u32 = 1032u32;
pub const ICON_INDEX_CONTACT: u32 = 512u32;
pub const ICON_INDEX_DECLINE: u32 = 1030u32;
pub const ICON_INDEX_DELIVERY_MAIL: u32 = 264u32;
pub const ICON_INDEX_DISTRIBUTION_LIST: u32 = 514u32;
pub const ICON_INDEX_FORWARDED_MAIL: u32 = 262u32;
pub const ICON_INDEX_INFORMATIONAL_UPDATE: u32 = 1033u32;
pub const ICON_INDEX_IRM_COMPOSE_MAIL: u32 = 309u32;
pub const ICON_INDEX_IRM_FORWARDED_MAIL: u32 = 307u32;
pub const ICON_INDEX_IRM_READ_MAIL: u32 = 305u32;
pub const ICON_INDEX_IRM_REPLIED_MAIL: u32 = 308u32;
pub const ICON_INDEX_IRM_UNREAD_MAIL: u32 = 306u32;
pub const ICON_INDEX_JOURNAL_CONVERSATION: u32 = 1537u32;
pub const ICON_INDEX_JOURNAL_DOCUMENT: u32 = 1554u32;
pub const ICON_INDEX_JOURNAL_EMAIL_MESSAGE: u32 = 1538u32;
pub const ICON_INDEX_JOURNAL_FAX: u32 = 1545u32;
pub const ICON_INDEX_JOURNAL_LETTER: u32 = 1548u32;
pub const ICON_INDEX_JOURNAL_MEETING: u32 = 1555u32;
pub const ICON_INDEX_JOURNAL_MEETING_CANCELLATION: u32 = 1556u32;
pub const ICON_INDEX_JOURNAL_MEETING_REQUEST: u32 = 1539u32;
pub const ICON_INDEX_JOURNAL_MEETING_RESPONSE: u32 = 1540u32;
pub const ICON_INDEX_JOURNAL_MICROSOFT_OFFICE_ACCESS: u32 = 1552u32;
pub const ICON_INDEX_JOURNAL_MICROSOFT_OFFICE_EXCEL: u32 = 1550u32;
pub const ICON_INDEX_JOURNAL_MICROSOFT_OFFICE_POWER_POINT: u32 = 1551u32;
pub const ICON_INDEX_JOURNAL_MICROSOFT_OFFICE_WORD: u32 = 1549u32;
pub const ICON_INDEX_JOURNAL_NOTE: u32 = 1544u32;
pub const ICON_INDEX_JOURNAL_PHONE_CALL: u32 = 1546u32;
pub const ICON_INDEX_JOURNAL_REMOTE_SESSION: u32 = 1557u32;
pub const ICON_INDEX_JOURNAL_TASK_REQUEST: u32 = 1542u32;
pub const ICON_INDEX_JOURNAL_TASK_RESPONSE: u32 = 1543u32;
pub const ICON_INDEX_MAIL_ENCRYPTED: u32 = 272u32;
pub const ICON_INDEX_MAIL_ENCRYPTED_FORWARDED: u32 = 277u32;
pub const ICON_INDEX_MAIL_ENCRYPTED_READ: u32 = 279u32;
pub const ICON_INDEX_MAIL_ENCRYPTED_REPLIED: u32 = 275u32;
pub const ICON_INDEX_MAIL_SIGNED: u32 = 271u32;
pub const ICON_INDEX_MAIL_SMIME_RECEIPT: u32 = 274u32;
pub const ICON_INDEX_MAIL_SMIME_SIGNED: u32 = 273u32;
pub const ICON_INDEX_MAIL_SMIME_SIGNED_FORWARDED: u32 = 278u32;
pub const ICON_INDEX_MAIL_SMIME_SIGNED_READ: u32 = 280u32;
pub const ICON_INDEX_MAIL_SMIME_SIGNED_REPLIED: u32 = 276u32;
pub const ICON_INDEX_MEETING_REQUEST: u32 = 1028u32;
pub const ICON_INDEX_NEW_MAIL: u32 = 4294967295u32;
pub const ICON_INDEX_NONDELIVERY_MAIL: u32 = 266u32;
pub const ICON_INDEX_NONREAD_MAIL: u32 = 267u32;
pub const ICON_INDEX_OTHER: u32 = 3u32;
pub const ICON_INDEX_OUT_OF_OFFICE_MAIL: u32 = 283u32;
pub const ICON_INDEX_POST: u32 = 1u32;
pub const ICON_INDEX_READ_MAIL: u32 = 256u32;
pub const ICON_INDEX_READ_RECEIPT_MAIL: u32 = 265u32;
pub const ICON_INDEX_RECALL_F_MAIL: u32 = 269u32;
pub const ICON_INDEX_RECALL_MAIL: u32 = 284u32;
pub const ICON_INDEX_RECALL_S_MAIL: u32 = 268u32;
pub const ICON_INDEX_RECEIPT_MAIL: u32 = 260u32;
pub const ICON_INDEX_RECURRING_APPOINTMENT: u32 = 1025u32;
pub const ICON_INDEX_RECURRING_MEETING: u32 = 1027u32;
pub const ICON_INDEX_REMOTE_MAIL: u32 = 263u32;
pub const ICON_INDEX_REPLIED_MAIL: u32 = 261u32;
pub const ICON_INDEX_SINGLE_INSTANCE_APPOINTMENT: u32 = 1024u32;
pub const ICON_INDEX_SINGLE_INSTANCE_MEETING: u32 = 1026u32;
pub const ICON_INDEX_STICKY_NOTE_BLUE: u32 = 768u32;
pub const ICON_INDEX_STICKY_NOTE_GREEN: u32 = 769u32;
pub const ICON_INDEX_STICKY_NOTE_PINK: u32 = 770u32;
pub const ICON_INDEX_STICKY_NOTE_WHITE: u32 = 772u32;
pub const ICON_INDEX_STICKY_NOTE_YELLOW: u32 = 771u32;
pub const ICON_INDEX_SUBMITTED_MAIL: u32 = 258u32;
pub const ICON_INDEX_TASK: u32 = 1280u32;
pub const ICON_INDEX_TASK_ACCEPTANCE: u32 = 1285u32;
pub const ICON_INDEX_TASK_REJECTION: u32 = 1286u32;
pub const ICON_INDEX_TASK_REQUEST: u32 = 1284u32;
pub const ICON_INDEX_TENTATIVE: u32 = 1031u32;
pub const ICON_INDEX_TRACKED_MAIL: u32 = 304u32;
pub const ICON_INDEX_TRACKING_MAIL: u32 = 270u32;
pub const ICON_INDEX_UNASSIGNED_RECURRING_TASK: u32 = 1281u32;
pub const ICON_INDEX_UNREAD_MAIL: u32 = 257u32;
pub const ICON_INDEX_UNSENT_MAIL: u32 = 259u32;
windows_core::imp::define_interface!(
    IDistList,
    IDistList_Vtbl,
    0x0002030e_0000_0000_c000_000000000046
);
impl core::ops::Deref for IDistList {
    type Target = IMAPIContainer;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IDistList,
    windows_core::IUnknown,
    IMAPIProp,
    IMAPIContainer
);
impl IDistList {
    pub unsafe fn CreateEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulcreateflags: u32,
        lppmapipropentry: *mut Option<IMAPIProp>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CreateEntry)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                ulcreateflags,
                core::mem::transmute(lppmapipropentry),
            )
            .ok()
        }
    }
    pub unsafe fn CopyEntries<P2>(
        &self,
        lpentries: *mut SBinaryArray,
        uluiparam: usize,
        lpprogress: P2,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CopyEntries)(
                windows_core::Interface::as_raw(self),
                lpentries as _,
                uluiparam,
                lpprogress.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn DeleteEntries(
        &self,
        lpentries: *mut SBinaryArray,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteEntries)(
                windows_core::Interface::as_raw(self),
                lpentries as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn ResolveNames(
        &self,
        lpproptagarray: *mut SPropTagArray,
        ulflags: u32,
        lpadrlist: *mut ADRLIST,
        lpflaglist: *mut FlagList,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ResolveNames)(
                windows_core::Interface::as_raw(self),
                lpproptagarray as _,
                ulflags,
                lpadrlist as _,
                lpflaglist as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IDistList_Vtbl {
    pub base__: IMAPIContainer_Vtbl,
    pub CreateEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CopyEntries: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SBinaryArray,
        usize,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub DeleteEntries: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SBinaryArray,
        u32,
    ) -> windows_core::HRESULT,
    pub ResolveNames: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SPropTagArray,
        u32,
        *mut ADRLIST,
        *mut FlagList,
    ) -> windows_core::HRESULT,
}
pub trait IDistList_Impl: IMAPIContainer_Impl {
    fn CreateEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulcreateflags: u32,
        lppmapipropentry: windows_core::OutRef<'_, IMAPIProp>,
    ) -> windows_core::Result<()>;
    fn CopyEntries(
        &self,
        lpentries: *mut SBinaryArray,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn DeleteEntries(&self, lpentries: *mut SBinaryArray, ulflags: u32)
        -> windows_core::Result<()>;
    fn ResolveNames(
        &self,
        lpproptagarray: *mut SPropTagArray,
        ulflags: u32,
        lpadrlist: *mut ADRLIST,
        lpflaglist: *mut FlagList,
    ) -> windows_core::Result<()>;
}
impl IDistList_Vtbl {
    pub const fn new<Identity: IDistList_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn CreateEntry<Identity: IDistList_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            ulcreateflags: u32,
            lppmapipropentry: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IDistList_Impl::CreateEntry(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&ulcreateflags),
                    core::mem::transmute_copy(&lppmapipropentry),
                )
                .into()
            }
        }
        unsafe extern "system" fn CopyEntries<Identity: IDistList_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpentries: *mut SBinaryArray,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IDistList_Impl::CopyEntries(
                    this,
                    core::mem::transmute_copy(&lpentries),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteEntries<Identity: IDistList_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpentries: *mut SBinaryArray,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IDistList_Impl::DeleteEntries(
                    this,
                    core::mem::transmute_copy(&lpentries),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn ResolveNames<Identity: IDistList_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpproptagarray: *mut SPropTagArray,
            ulflags: u32,
            lpadrlist: *mut ADRLIST,
            lpflaglist: *mut FlagList,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IDistList_Impl::ResolveNames(
                    this,
                    core::mem::transmute_copy(&lpproptagarray),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpadrlist),
                    core::mem::transmute_copy(&lpflaglist),
                )
                .into()
            }
        }
        Self {
            base__: IMAPIContainer_Vtbl::new::<Identity, OFFSET>(),
            CreateEntry: CreateEntry::<Identity, OFFSET>,
            CopyEntries: CopyEntries::<Identity, OFFSET>,
            DeleteEntries: DeleteEntries::<Identity, OFFSET>,
            ResolveNames: ResolveNames::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IDistList as windows_core::Interface>::IID
            || iid == &<IMAPIProp as windows_core::Interface>::IID
            || iid == &<IMAPIContainer as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IDistList {}
pub const IDistList_CopyEntries: METHODS = METHODS(47i32);
pub const IDistList_CreateEntry: METHODS = METHODS(46i32);
pub const IDistList_DeleteEntries: METHODS = METHODS(48i32);
pub const IDistList_ResolveNames: METHODS = METHODS(49i32);
pub const IET_7BIT: ENCODINGTYPE = ENCODINGTYPE(4i32);
pub const IET_8BIT: ENCODINGTYPE = ENCODINGTYPE(5i32);
pub const IET_BASE64: ENCODINGTYPE = ENCODINGTYPE(1i32);
pub const IET_BINARY: ENCODINGTYPE = ENCODINGTYPE(0i32);
pub const IET_BINHEX40: ENCODINGTYPE = ENCODINGTYPE(12i32);
pub const IET_CURRENT: ENCODINGTYPE = ENCODINGTYPE(10i32);
pub const IET_ENCODED: ENCODINGTYPE = ENCODINGTYPE(9i32);
pub const IET_INETCSET: ENCODINGTYPE = ENCODINGTYPE(6i32);
pub const IET_LAST: ENCODINGTYPE = ENCODINGTYPE(13i32);
pub const IET_QP: ENCODINGTYPE = ENCODINGTYPE(3i32);
pub const IET_RFC1522: ENCODINGTYPE = ENCODINGTYPE(8i32);
pub const IET_UNICODE: ENCODINGTYPE = ENCODINGTYPE(7i32);
pub const IET_UNKNOWN: ENCODINGTYPE = ENCODINGTYPE(11i32);
pub const IET_UUENCODE: ENCODINGTYPE = ENCODINGTYPE(2i32);
windows_core::imp::define_interface!(
    IExchangeBadItemCallback,
    IExchangeBadItemCallback_Vtbl,
    0x1df85ab7_4d20_4a57_b170_2f062136c1d6
);
windows_core::imp::interface_hierarchy!(IExchangeBadItemCallback, windows_core::IUnknown);
impl IExchangeBadItemCallback {
    pub unsafe fn BadItem<P2>(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lpwszfoldername: P2,
        lpsbfoldereid: *mut SBinary,
        cvalues: u32,
        lpproparray: *mut SPropValue,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<windows_core::PCWSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).BadItem)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lpwszfoldername.param().abi(),
                lpsbfoldereid as _,
                cvalues,
                lpproparray as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeBadItemCallback_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub BadItem: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        windows_core::PCWSTR,
        *mut SBinary,
        u32,
        *mut SPropValue,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeBadItemCallback_Impl: windows_core::IUnknownImpl {
    fn BadItem(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lpwszfoldername: &windows_core::PCWSTR,
        lpsbfoldereid: *mut SBinary,
        cvalues: u32,
        lpproparray: *mut SPropValue,
    ) -> windows_core::Result<()>;
}
impl IExchangeBadItemCallback_Vtbl {
    pub const fn new<Identity: IExchangeBadItemCallback_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn BadItem<
            Identity: IExchangeBadItemCallback_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lpwszfoldername: windows_core::PCWSTR,
            lpsbfoldereid: *mut SBinary,
            cvalues: u32,
            lpproparray: *mut SPropValue,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeBadItemCallback_Impl::BadItem(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute(&lpwszfoldername),
                    core::mem::transmute_copy(&lpsbfoldereid),
                    core::mem::transmute_copy(&cvalues),
                    core::mem::transmute_copy(&lpproparray),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            BadItem: BadItem::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeBadItemCallback as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeBadItemCallback {}
windows_core::imp::define_interface!(IExchangeChangeAdviseSink, IExchangeChangeAdviseSink_Vtbl, 0);
windows_core::imp::interface_hierarchy!(IExchangeChangeAdviseSink, windows_core::IUnknown);
impl IExchangeChangeAdviseSink {
    pub unsafe fn OnNotify(&self, ulflags: u32, lpentrylist: *mut SBinaryArray) -> u32 {
        unsafe {
            (windows_core::Interface::vtable(self).OnNotify)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpentrylist as _,
            )
        }
    }
}
#[repr(C)]
pub struct IExchangeChangeAdviseSink_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub OnNotify: unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut SBinaryArray) -> u32,
}
pub trait IExchangeChangeAdviseSink_Impl: windows_core::IUnknownImpl {
    fn OnNotify(&self, ulflags: u32, lpentrylist: *mut SBinaryArray) -> u32;
}
impl IExchangeChangeAdviseSink_Vtbl {
    pub const fn new<Identity: IExchangeChangeAdviseSink_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn OnNotify<
            Identity: IExchangeChangeAdviseSink_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpentrylist: *mut SBinaryArray,
        ) -> u32 {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeChangeAdviseSink_Impl::OnNotify(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpentrylist),
                )
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            OnNotify: OnNotify::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeChangeAdviseSink as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeChangeAdviseSink {}
windows_core::imp::define_interface!(
    IExchangeChangeAdvisor,
    IExchangeChangeAdvisor_Vtbl,
    0x1e300720_a839_11cf_bde0_00004c7531e3
);
windows_core::imp::interface_hierarchy!(IExchangeChangeAdvisor, windows_core::IUnknown);
impl IExchangeChangeAdvisor {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn Config<P0, P2>(
        &self,
        lpstream: P0,
        lpguid: *mut windows_core::GUID,
        lpadvisesink: P2,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
        P2: windows_core::Param<IExchangeChangeAdviseSink>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Config)(
                windows_core::Interface::as_raw(self),
                lpstream.param().abi(),
                lpguid as _,
                lpadvisesink.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn UpdateState<P0>(&self, lpstream: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).UpdateState)(
                windows_core::Interface::as_raw(self),
                lpstream.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn AddKeys(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).AddKeys)(
                windows_core::Interface::as_raw(self),
                lpentrylist as _,
            )
            .ok()
        }
    }
    pub unsafe fn RemoveKeys(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).RemoveKeys)(
                windows_core::Interface::as_raw(self),
                lpentrylist as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeChangeAdvisor_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub Config: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub UpdateState: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub AddKeys: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SBinaryArray,
    ) -> windows_core::HRESULT,
    pub RemoveKeys: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SBinaryArray,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeChangeAdvisor_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn Config(
        &self,
        lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        lpguid: *mut windows_core::GUID,
        lpadvisesink: windows_core::Ref<'_, IExchangeChangeAdviseSink>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn UpdateState(
        &self,
        lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()>;
    fn AddKeys(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()>;
    fn RemoveKeys(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()>;
}
impl IExchangeChangeAdvisor_Vtbl {
    pub const fn new<Identity: IExchangeChangeAdvisor_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IExchangeChangeAdvisor_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeChangeAdvisor_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn Config<
            Identity: IExchangeChangeAdvisor_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpstream: *mut core::ffi::c_void,
            lpguid: *mut windows_core::GUID,
            lpadvisesink: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeChangeAdvisor_Impl::Config(
                    this,
                    core::mem::transmute_copy(&lpstream),
                    core::mem::transmute_copy(&lpguid),
                    core::mem::transmute_copy(&lpadvisesink),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn UpdateState<
            Identity: IExchangeChangeAdvisor_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpstream: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeChangeAdvisor_Impl::UpdateState(this, core::mem::transmute_copy(&lpstream))
                    .into()
            }
        }
        unsafe extern "system" fn AddKeys<
            Identity: IExchangeChangeAdvisor_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpentrylist: *mut SBinaryArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeChangeAdvisor_Impl::AddKeys(this, core::mem::transmute_copy(&lpentrylist))
                    .into()
            }
        }
        unsafe extern "system" fn RemoveKeys<
            Identity: IExchangeChangeAdvisor_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpentrylist: *mut SBinaryArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeChangeAdvisor_Impl::RemoveKeys(
                    this,
                    core::mem::transmute_copy(&lpentrylist),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            Config: Config::<Identity, OFFSET>,
            UpdateState: UpdateState::<Identity, OFFSET>,
            AddKeys: AddKeys::<Identity, OFFSET>,
            RemoveKeys: RemoveKeys::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeChangeAdvisor as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeChangeAdvisor {}
windows_core::imp::define_interface!(
    IExchangeExportChanges,
    IExchangeExportChanges_Vtbl,
    0xa3ea9cc0_d1b2_11cd_80fc_00aa004bba0b
);
windows_core::imp::interface_hierarchy!(IExchangeExportChanges, windows_core::IUnknown);
impl IExchangeExportChanges {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn Config<P0, P2>(
        &self,
        lpstream: P0,
        ulflags: u32,
        lpunk: P2,
        lprestriction: *mut SRestriction,
        lpincludeprops: *mut SPropTagArray,
        lpexcludeprops: *mut SPropTagArray,
        ulbuffersize: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
        P2: windows_core::Param<windows_core::IUnknown>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Config)(
                windows_core::Interface::as_raw(self),
                lpstream.param().abi(),
                ulflags,
                lpunk.param().abi(),
                lprestriction as _,
                lpincludeprops as _,
                lpexcludeprops as _,
                ulbuffersize,
            )
            .ok()
        }
    }
    pub unsafe fn Synchronize(
        &self,
        lpulsteps: *mut u32,
        lpulprogress: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Synchronize)(
                windows_core::Interface::as_raw(self),
                lpulsteps as _,
                lpulprogress as _,
            )
            .ok()
        }
    }
    pub unsafe fn UpdateState<P0>(&self, lpstream: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).UpdateState)(
                windows_core::Interface::as_raw(self),
                lpstream.param().abi(),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeExportChanges_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub Config: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
        *mut SRestriction,
        *mut SPropTagArray,
        *mut SPropTagArray,
        u32,
    ) -> windows_core::HRESULT,
    pub Synchronize: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut u32,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub UpdateState: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeExportChanges_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn Config(
        &self,
        lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        ulflags: u32,
        lpunk: windows_core::Ref<'_, windows_core::IUnknown>,
        lprestriction: *mut SRestriction,
        lpincludeprops: *mut SPropTagArray,
        lpexcludeprops: *mut SPropTagArray,
        ulbuffersize: u32,
    ) -> windows_core::Result<()>;
    fn Synchronize(&self, lpulsteps: *mut u32, lpulprogress: *mut u32) -> windows_core::Result<()>;
    fn UpdateState(
        &self,
        lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()>;
}
impl IExchangeExportChanges_Vtbl {
    pub const fn new<Identity: IExchangeExportChanges_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IExchangeExportChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeExportChanges_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn Config<
            Identity: IExchangeExportChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpstream: *mut core::ffi::c_void,
            ulflags: u32,
            lpunk: *mut core::ffi::c_void,
            lprestriction: *mut SRestriction,
            lpincludeprops: *mut SPropTagArray,
            lpexcludeprops: *mut SPropTagArray,
            ulbuffersize: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeExportChanges_Impl::Config(
                    this,
                    core::mem::transmute_copy(&lpstream),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpunk),
                    core::mem::transmute_copy(&lprestriction),
                    core::mem::transmute_copy(&lpincludeprops),
                    core::mem::transmute_copy(&lpexcludeprops),
                    core::mem::transmute_copy(&ulbuffersize),
                )
                .into()
            }
        }
        unsafe extern "system" fn Synchronize<
            Identity: IExchangeExportChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpulsteps: *mut u32,
            lpulprogress: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeExportChanges_Impl::Synchronize(
                    this,
                    core::mem::transmute_copy(&lpulsteps),
                    core::mem::transmute_copy(&lpulprogress),
                )
                .into()
            }
        }
        unsafe extern "system" fn UpdateState<
            Identity: IExchangeExportChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpstream: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeExportChanges_Impl::UpdateState(this, core::mem::transmute_copy(&lpstream))
                    .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            Config: Config::<Identity, OFFSET>,
            Synchronize: Synchronize::<Identity, OFFSET>,
            UpdateState: UpdateState::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeExportChanges as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeExportChanges {}
windows_core::imp::define_interface!(
    IExchangeExportChanges2,
    IExchangeExportChanges2_Vtbl,
    0x387cebe0_f53f_11cf_a48f_00c04fd65595
);
impl core::ops::Deref for IExchangeExportChanges2 {
    type Target = IExchangeExportChanges;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IExchangeExportChanges2,
    windows_core::IUnknown,
    IExchangeExportChanges
);
impl IExchangeExportChanges2 {
    pub unsafe fn ConfigForConversionStream<P0, P2>(
        &self,
        lpstream: P0,
        ulflags: u32,
        lpunk: P2,
        lprestriction: *mut SRestriction,
        cvaluesconversion: u32,
        lpproparrayconversion: *mut SPropValue,
        ulbuffersize: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
        P2: windows_core::Param<windows_core::IUnknown>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).ConfigForConversionStream)(
                windows_core::Interface::as_raw(self),
                lpstream.param().abi(),
                ulflags,
                lpunk.param().abi(),
                lprestriction as _,
                cvaluesconversion,
                lpproparrayconversion as _,
                ulbuffersize,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeExportChanges2_Vtbl {
    pub base__: IExchangeExportChanges_Vtbl,
    pub ConfigForConversionStream: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
        *mut SRestriction,
        u32,
        *mut SPropValue,
        u32,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeExportChanges2_Impl: IExchangeExportChanges_Impl {
    fn ConfigForConversionStream(
        &self,
        lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        ulflags: u32,
        lpunk: windows_core::Ref<'_, windows_core::IUnknown>,
        lprestriction: *mut SRestriction,
        cvaluesconversion: u32,
        lpproparrayconversion: *mut SPropValue,
        ulbuffersize: u32,
    ) -> windows_core::Result<()>;
}
impl IExchangeExportChanges2_Vtbl {
    pub const fn new<Identity: IExchangeExportChanges2_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn ConfigForConversionStream<
            Identity: IExchangeExportChanges2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpstream: *mut core::ffi::c_void,
            ulflags: u32,
            lpunk: *mut core::ffi::c_void,
            lprestriction: *mut SRestriction,
            cvaluesconversion: u32,
            lpproparrayconversion: *mut SPropValue,
            ulbuffersize: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeExportChanges2_Impl::ConfigForConversionStream(
                    this,
                    core::mem::transmute_copy(&lpstream),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpunk),
                    core::mem::transmute_copy(&lprestriction),
                    core::mem::transmute_copy(&cvaluesconversion),
                    core::mem::transmute_copy(&lpproparrayconversion),
                    core::mem::transmute_copy(&ulbuffersize),
                )
                .into()
            }
        }
        Self {
            base__: IExchangeExportChanges_Vtbl::new::<Identity, OFFSET>(),
            ConfigForConversionStream: ConfigForConversionStream::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeExportChanges2 as windows_core::Interface>::IID
            || iid == &<IExchangeExportChanges as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeExportChanges2 {}
windows_core::imp::define_interface!(
    IExchangeExportChanges3,
    IExchangeExportChanges3_Vtbl,
    0x702e7f86_50a6_11d1_abd6_00a0c905660a
);
impl core::ops::Deref for IExchangeExportChanges3 {
    type Target = IExchangeExportChanges2;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IExchangeExportChanges3,
    windows_core::IUnknown,
    IExchangeExportChanges,
    IExchangeExportChanges2
);
impl IExchangeExportChanges3 {
    pub unsafe fn ConfigForSelectiveSync<P0, P2>(
        &self,
        lpstream: P0,
        ulflags: u32,
        lpunk: P2,
        lpmsglist: *mut SBinaryArray,
        lprestriction: *mut SRestriction,
        lpincludeprops: *mut SPropTagArray,
        lpexcludeprops: *mut SPropTagArray,
        ulbuffersize: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
        P2: windows_core::Param<windows_core::IUnknown>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).ConfigForSelectiveSync)(
                windows_core::Interface::as_raw(self),
                lpstream.param().abi(),
                ulflags,
                lpunk.param().abi(),
                lpmsglist as _,
                lprestriction as _,
                lpincludeprops as _,
                lpexcludeprops as _,
                ulbuffersize,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeExportChanges3_Vtbl {
    pub base__: IExchangeExportChanges2_Vtbl,
    pub ConfigForSelectiveSync: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
        *mut SBinaryArray,
        *mut SRestriction,
        *mut SPropTagArray,
        *mut SPropTagArray,
        u32,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeExportChanges3_Impl: IExchangeExportChanges2_Impl {
    fn ConfigForSelectiveSync(
        &self,
        lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        ulflags: u32,
        lpunk: windows_core::Ref<'_, windows_core::IUnknown>,
        lpmsglist: *mut SBinaryArray,
        lprestriction: *mut SRestriction,
        lpincludeprops: *mut SPropTagArray,
        lpexcludeprops: *mut SPropTagArray,
        ulbuffersize: u32,
    ) -> windows_core::Result<()>;
}
impl IExchangeExportChanges3_Vtbl {
    pub const fn new<Identity: IExchangeExportChanges3_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn ConfigForSelectiveSync<
            Identity: IExchangeExportChanges3_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpstream: *mut core::ffi::c_void,
            ulflags: u32,
            lpunk: *mut core::ffi::c_void,
            lpmsglist: *mut SBinaryArray,
            lprestriction: *mut SRestriction,
            lpincludeprops: *mut SPropTagArray,
            lpexcludeprops: *mut SPropTagArray,
            ulbuffersize: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeExportChanges3_Impl::ConfigForSelectiveSync(
                    this,
                    core::mem::transmute_copy(&lpstream),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpunk),
                    core::mem::transmute_copy(&lpmsglist),
                    core::mem::transmute_copy(&lprestriction),
                    core::mem::transmute_copy(&lpincludeprops),
                    core::mem::transmute_copy(&lpexcludeprops),
                    core::mem::transmute_copy(&ulbuffersize),
                )
                .into()
            }
        }
        Self {
            base__: IExchangeExportChanges2_Vtbl::new::<Identity, OFFSET>(),
            ConfigForSelectiveSync: ConfigForSelectiveSync::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeExportChanges3 as windows_core::Interface>::IID
            || iid == &<IExchangeExportChanges as windows_core::Interface>::IID
            || iid == &<IExchangeExportChanges2 as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeExportChanges3 {}
windows_core::imp::define_interface!(
    IExchangeFastTransfer,
    IExchangeFastTransfer_Vtbl,
    0xff7db070_a88a_11cd_9bc8_00aa002fc45a
);
windows_core::imp::interface_hierarchy!(IExchangeFastTransfer, windows_core::IUnknown);
impl IExchangeFastTransfer {
    pub unsafe fn Config(&self, ulflags: u32, ultransfermethod: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Config)(
                windows_core::Interface::as_raw(self),
                ulflags,
                ultransfermethod,
            )
            .ok()
        }
    }
    pub unsafe fn TransferBuffer(
        &self,
        cb: u32,
        lpb: *mut u8,
        lpcbprocessed: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).TransferBuffer)(
                windows_core::Interface::as_raw(self),
                cb,
                lpb as _,
                lpcbprocessed as _,
            )
            .ok()
        }
    }
    pub unsafe fn IsInterfaceOk(
        &self,
        ultransfermethod: u32,
        refiid: *const windows_core::GUID,
        lpptaglist: *mut SPropTagArray,
        ulflags: u32,
    ) -> windows_core::BOOL {
        unsafe {
            (windows_core::Interface::vtable(self).IsInterfaceOk)(
                windows_core::Interface::as_raw(self),
                ultransfermethod,
                refiid,
                lpptaglist as _,
                ulflags,
            )
        }
    }
}
#[repr(C)]
pub struct IExchangeFastTransfer_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Config:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32) -> windows_core::HRESULT,
    pub TransferBuffer: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut u8,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub IsInterfaceOk: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *const windows_core::GUID,
        *mut SPropTagArray,
        u32,
    ) -> windows_core::BOOL,
}
pub trait IExchangeFastTransfer_Impl: windows_core::IUnknownImpl {
    fn Config(&self, ulflags: u32, ultransfermethod: u32) -> windows_core::Result<()>;
    fn TransferBuffer(
        &self,
        cb: u32,
        lpb: *mut u8,
        lpcbprocessed: *mut u32,
    ) -> windows_core::Result<()>;
    fn IsInterfaceOk(
        &self,
        ultransfermethod: u32,
        refiid: *const windows_core::GUID,
        lpptaglist: *mut SPropTagArray,
        ulflags: u32,
    ) -> windows_core::BOOL;
}
impl IExchangeFastTransfer_Vtbl {
    pub const fn new<Identity: IExchangeFastTransfer_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Config<
            Identity: IExchangeFastTransfer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            ultransfermethod: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeFastTransfer_Impl::Config(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&ultransfermethod),
                )
                .into()
            }
        }
        unsafe extern "system" fn TransferBuffer<
            Identity: IExchangeFastTransfer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cb: u32,
            lpb: *mut u8,
            lpcbprocessed: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeFastTransfer_Impl::TransferBuffer(
                    this,
                    core::mem::transmute_copy(&cb),
                    core::mem::transmute_copy(&lpb),
                    core::mem::transmute_copy(&lpcbprocessed),
                )
                .into()
            }
        }
        unsafe extern "system" fn IsInterfaceOk<
            Identity: IExchangeFastTransfer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ultransfermethod: u32,
            refiid: *const windows_core::GUID,
            lpptaglist: *mut SPropTagArray,
            ulflags: u32,
        ) -> windows_core::BOOL {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeFastTransfer_Impl::IsInterfaceOk(
                    this,
                    core::mem::transmute_copy(&ultransfermethod),
                    core::mem::transmute_copy(&refiid),
                    core::mem::transmute_copy(&lpptaglist),
                    core::mem::transmute_copy(&ulflags),
                )
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Config: Config::<Identity, OFFSET>,
            TransferBuffer: TransferBuffer::<Identity, OFFSET>,
            IsInterfaceOk: IsInterfaceOk::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeFastTransfer as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeFastTransfer {}
windows_core::imp::define_interface!(
    IExchangeFavorites,
    IExchangeFavorites_Vtbl,
    0xcf4f3bc0_ec66_11ce_b31c_00aa00574cc6
);
windows_core::imp::interface_hierarchy!(IExchangeFavorites, windows_core::IUnknown);
impl IExchangeFavorites {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn AddFavorites(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).AddFavorites)(
                windows_core::Interface::as_raw(self),
                lpentrylist as _,
            )
            .ok()
        }
    }
    pub unsafe fn DelFavorites(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DelFavorites)(
                windows_core::Interface::as_raw(self),
                lpentrylist as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeFavorites_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub AddFavorites: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SBinaryArray,
    ) -> windows_core::HRESULT,
    pub DelFavorites: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SBinaryArray,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeFavorites_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn AddFavorites(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()>;
    fn DelFavorites(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()>;
}
impl IExchangeFavorites_Vtbl {
    pub const fn new<Identity: IExchangeFavorites_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IExchangeFavorites_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeFavorites_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn AddFavorites<
            Identity: IExchangeFavorites_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpentrylist: *mut SBinaryArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeFavorites_Impl::AddFavorites(this, core::mem::transmute_copy(&lpentrylist))
                    .into()
            }
        }
        unsafe extern "system" fn DelFavorites<
            Identity: IExchangeFavorites_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpentrylist: *mut SBinaryArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeFavorites_Impl::DelFavorites(this, core::mem::transmute_copy(&lpentrylist))
                    .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            AddFavorites: AddFavorites::<Identity, OFFSET>,
            DelFavorites: DelFavorites::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeFavorites as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeFavorites {}
windows_core::imp::define_interface!(
    IExchangeImportContentsChanges,
    IExchangeImportContentsChanges_Vtbl,
    0xf75abfa0_d0e0_11cd_80fc_00aa004bba0b
);
windows_core::imp::interface_hierarchy!(IExchangeImportContentsChanges, windows_core::IUnknown);
impl IExchangeImportContentsChanges {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn Config<P0>(&self, lpstream: P0, ulflags: u32) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Config)(
                windows_core::Interface::as_raw(self),
                lpstream.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn UpdateState<P0>(&self, lpstream: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).UpdateState)(
                windows_core::Interface::as_raw(self),
                lpstream.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn ImportMessageChange(
        &self,
        cpvalchanges: u32,
        ppvalchanges: *mut SPropValue,
        ulflags: u32,
        lppmessage: *mut Option<IMessage>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ImportMessageChange)(
                windows_core::Interface::as_raw(self),
                cpvalchanges,
                ppvalchanges as _,
                ulflags,
                core::mem::transmute(lppmessage),
            )
            .ok()
        }
    }
    pub unsafe fn ImportMessageDeletion(
        &self,
        ulflags: u32,
        lpsrcentrylist: *mut SBinaryArray,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ImportMessageDeletion)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpsrcentrylist as _,
            )
            .ok()
        }
    }
    pub unsafe fn ImportPerUserReadStateChange(
        &self,
        celements: u32,
        lpreadstate: *mut READSTATE,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ImportPerUserReadStateChange)(
                windows_core::Interface::as_raw(self),
                celements,
                lpreadstate as _,
            )
            .ok()
        }
    }
    pub unsafe fn ImportMessageMove(
        &self,
        cbsourcekeysrcfolder: u32,
        pbsourcekeysrcfolder: *mut u8,
        cbsourcekeysrcmessage: u32,
        pbsourcekeysrcmessage: *mut u8,
        cbpclmessage: u32,
        pbpclmessage: *mut u8,
        cbsourcekeydestmessage: u32,
        pbsourcekeydestmessage: *mut u8,
        cbchangenumdestmessage: u32,
        pbchangenumdestmessage: *mut u8,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ImportMessageMove)(
                windows_core::Interface::as_raw(self),
                cbsourcekeysrcfolder,
                pbsourcekeysrcfolder as _,
                cbsourcekeysrcmessage,
                pbsourcekeysrcmessage as _,
                cbpclmessage,
                pbpclmessage as _,
                cbsourcekeydestmessage,
                pbsourcekeydestmessage as _,
                cbchangenumdestmessage,
                pbchangenumdestmessage as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeImportContentsChanges_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub Config: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub UpdateState: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ImportMessageChange: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut SPropValue,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ImportMessageDeletion: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut SBinaryArray,
    ) -> windows_core::HRESULT,
    pub ImportPerUserReadStateChange: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut READSTATE,
    ) -> windows_core::HRESULT,
    pub ImportMessageMove: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut u8,
        u32,
        *mut u8,
        u32,
        *mut u8,
        u32,
        *mut u8,
        u32,
        *mut u8,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeImportContentsChanges_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn Config(
        &self,
        lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn UpdateState(
        &self,
        lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()>;
    fn ImportMessageChange(
        &self,
        cpvalchanges: u32,
        ppvalchanges: *mut SPropValue,
        ulflags: u32,
        lppmessage: windows_core::OutRef<'_, IMessage>,
    ) -> windows_core::Result<()>;
    fn ImportMessageDeletion(
        &self,
        ulflags: u32,
        lpsrcentrylist: *mut SBinaryArray,
    ) -> windows_core::Result<()>;
    fn ImportPerUserReadStateChange(
        &self,
        celements: u32,
        lpreadstate: *mut READSTATE,
    ) -> windows_core::Result<()>;
    fn ImportMessageMove(
        &self,
        cbsourcekeysrcfolder: u32,
        pbsourcekeysrcfolder: *mut u8,
        cbsourcekeysrcmessage: u32,
        pbsourcekeysrcmessage: *mut u8,
        cbpclmessage: u32,
        pbpclmessage: *mut u8,
        cbsourcekeydestmessage: u32,
        pbsourcekeydestmessage: *mut u8,
        cbchangenumdestmessage: u32,
        pbchangenumdestmessage: *mut u8,
    ) -> windows_core::Result<()>;
}
impl IExchangeImportContentsChanges_Vtbl {
    pub const fn new<Identity: IExchangeImportContentsChanges_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IExchangeImportContentsChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportContentsChanges_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn Config<
            Identity: IExchangeImportContentsChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpstream: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportContentsChanges_Impl::Config(
                    this,
                    core::mem::transmute_copy(&lpstream),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn UpdateState<
            Identity: IExchangeImportContentsChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpstream: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportContentsChanges_Impl::UpdateState(
                    this,
                    core::mem::transmute_copy(&lpstream),
                )
                .into()
            }
        }
        unsafe extern "system" fn ImportMessageChange<
            Identity: IExchangeImportContentsChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cpvalchanges: u32,
            ppvalchanges: *mut SPropValue,
            ulflags: u32,
            lppmessage: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportContentsChanges_Impl::ImportMessageChange(
                    this,
                    core::mem::transmute_copy(&cpvalchanges),
                    core::mem::transmute_copy(&ppvalchanges),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmessage),
                )
                .into()
            }
        }
        unsafe extern "system" fn ImportMessageDeletion<
            Identity: IExchangeImportContentsChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpsrcentrylist: *mut SBinaryArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportContentsChanges_Impl::ImportMessageDeletion(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpsrcentrylist),
                )
                .into()
            }
        }
        unsafe extern "system" fn ImportPerUserReadStateChange<
            Identity: IExchangeImportContentsChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            celements: u32,
            lpreadstate: *mut READSTATE,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportContentsChanges_Impl::ImportPerUserReadStateChange(
                    this,
                    core::mem::transmute_copy(&celements),
                    core::mem::transmute_copy(&lpreadstate),
                )
                .into()
            }
        }
        unsafe extern "system" fn ImportMessageMove<
            Identity: IExchangeImportContentsChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cbsourcekeysrcfolder: u32,
            pbsourcekeysrcfolder: *mut u8,
            cbsourcekeysrcmessage: u32,
            pbsourcekeysrcmessage: *mut u8,
            cbpclmessage: u32,
            pbpclmessage: *mut u8,
            cbsourcekeydestmessage: u32,
            pbsourcekeydestmessage: *mut u8,
            cbchangenumdestmessage: u32,
            pbchangenumdestmessage: *mut u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportContentsChanges_Impl::ImportMessageMove(
                    this,
                    core::mem::transmute_copy(&cbsourcekeysrcfolder),
                    core::mem::transmute_copy(&pbsourcekeysrcfolder),
                    core::mem::transmute_copy(&cbsourcekeysrcmessage),
                    core::mem::transmute_copy(&pbsourcekeysrcmessage),
                    core::mem::transmute_copy(&cbpclmessage),
                    core::mem::transmute_copy(&pbpclmessage),
                    core::mem::transmute_copy(&cbsourcekeydestmessage),
                    core::mem::transmute_copy(&pbsourcekeydestmessage),
                    core::mem::transmute_copy(&cbchangenumdestmessage),
                    core::mem::transmute_copy(&pbchangenumdestmessage),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            Config: Config::<Identity, OFFSET>,
            UpdateState: UpdateState::<Identity, OFFSET>,
            ImportMessageChange: ImportMessageChange::<Identity, OFFSET>,
            ImportMessageDeletion: ImportMessageDeletion::<Identity, OFFSET>,
            ImportPerUserReadStateChange: ImportPerUserReadStateChange::<Identity, OFFSET>,
            ImportMessageMove: ImportMessageMove::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeImportContentsChanges as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeImportContentsChanges {}
windows_core::imp::define_interface!(
    IExchangeImportContentsChanges2,
    IExchangeImportContentsChanges2_Vtbl,
    0x7dfdd720_f53f_11cf_a48f_00c04fd65595
);
impl core::ops::Deref for IExchangeImportContentsChanges2 {
    type Target = IExchangeImportContentsChanges;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IExchangeImportContentsChanges2,
    windows_core::IUnknown,
    IExchangeImportContentsChanges
);
impl IExchangeImportContentsChanges2 {
    pub unsafe fn ConfigForConversionStream<P0>(
        &self,
        lpstream: P0,
        ulflags: u32,
        cvaluesconversion: u32,
        lpproparrayconversion: *mut SPropValue,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).ConfigForConversionStream)(
                windows_core::Interface::as_raw(self),
                lpstream.param().abi(),
                ulflags,
                cvaluesconversion,
                lpproparrayconversion as _,
            )
            .ok()
        }
    }
    pub unsafe fn ImportMessageChangeAsAStream(
        &self,
        cpvalchanges: u32,
        ppvalchanges: *mut SPropValue,
        ulflags: u32,
        lppstream: *mut Option<windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ImportMessageChangeAsAStream)(
                windows_core::Interface::as_raw(self),
                cpvalchanges,
                ppvalchanges as _,
                ulflags,
                core::mem::transmute(lppstream),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeImportContentsChanges2_Vtbl {
    pub base__: IExchangeImportContentsChanges_Vtbl,
    pub ConfigForConversionStream: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut SPropValue,
    ) -> windows_core::HRESULT,
    pub ImportMessageChangeAsAStream: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut SPropValue,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeImportContentsChanges2_Impl: IExchangeImportContentsChanges_Impl {
    fn ConfigForConversionStream(
        &self,
        lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        ulflags: u32,
        cvaluesconversion: u32,
        lpproparrayconversion: *mut SPropValue,
    ) -> windows_core::Result<()>;
    fn ImportMessageChangeAsAStream(
        &self,
        cpvalchanges: u32,
        ppvalchanges: *mut SPropValue,
        ulflags: u32,
        lppstream: windows_core::OutRef<'_, windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()>;
}
impl IExchangeImportContentsChanges2_Vtbl {
    pub const fn new<Identity: IExchangeImportContentsChanges2_Impl, const OFFSET: isize>() -> Self
    {
        unsafe extern "system" fn ConfigForConversionStream<
            Identity: IExchangeImportContentsChanges2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpstream: *mut core::ffi::c_void,
            ulflags: u32,
            cvaluesconversion: u32,
            lpproparrayconversion: *mut SPropValue,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportContentsChanges2_Impl::ConfigForConversionStream(
                    this,
                    core::mem::transmute_copy(&lpstream),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&cvaluesconversion),
                    core::mem::transmute_copy(&lpproparrayconversion),
                )
                .into()
            }
        }
        unsafe extern "system" fn ImportMessageChangeAsAStream<
            Identity: IExchangeImportContentsChanges2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cpvalchanges: u32,
            ppvalchanges: *mut SPropValue,
            ulflags: u32,
            lppstream: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportContentsChanges2_Impl::ImportMessageChangeAsAStream(
                    this,
                    core::mem::transmute_copy(&cpvalchanges),
                    core::mem::transmute_copy(&ppvalchanges),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppstream),
                )
                .into()
            }
        }
        Self {
            base__: IExchangeImportContentsChanges_Vtbl::new::<Identity, OFFSET>(),
            ConfigForConversionStream: ConfigForConversionStream::<Identity, OFFSET>,
            ImportMessageChangeAsAStream: ImportMessageChangeAsAStream::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeImportContentsChanges2 as windows_core::Interface>::IID
            || iid == &<IExchangeImportContentsChanges as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeImportContentsChanges2 {}
windows_core::imp::define_interface!(
    IExchangeImportHierarchyChanges,
    IExchangeImportHierarchyChanges_Vtbl,
    0x85a66cf0_d0e0_11cd_80fc_00aa004bba0b
);
windows_core::imp::interface_hierarchy!(IExchangeImportHierarchyChanges, windows_core::IUnknown);
impl IExchangeImportHierarchyChanges {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn Config<P0>(&self, lpstream: P0, ulflags: u32) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Config)(
                windows_core::Interface::as_raw(self),
                lpstream.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn UpdateState<P0>(&self, lpstream: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).UpdateState)(
                windows_core::Interface::as_raw(self),
                lpstream.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn ImportFolderChange(
        &self,
        cpvalchanges: u32,
        ppvalchanges: *mut SPropValue,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ImportFolderChange)(
                windows_core::Interface::as_raw(self),
                cpvalchanges,
                ppvalchanges as _,
            )
            .ok()
        }
    }
    pub unsafe fn ImportFolderDeletion(
        &self,
        ulflags: u32,
        lpsrcentrylist: *mut SBinaryArray,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ImportFolderDeletion)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpsrcentrylist as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeImportHierarchyChanges_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub Config: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub UpdateState: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ImportFolderChange: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut SPropValue,
    ) -> windows_core::HRESULT,
    pub ImportFolderDeletion: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut SBinaryArray,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeImportHierarchyChanges_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn Config(
        &self,
        lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn UpdateState(
        &self,
        lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()>;
    fn ImportFolderChange(
        &self,
        cpvalchanges: u32,
        ppvalchanges: *mut SPropValue,
    ) -> windows_core::Result<()>;
    fn ImportFolderDeletion(
        &self,
        ulflags: u32,
        lpsrcentrylist: *mut SBinaryArray,
    ) -> windows_core::Result<()>;
}
impl IExchangeImportHierarchyChanges_Vtbl {
    pub const fn new<Identity: IExchangeImportHierarchyChanges_Impl, const OFFSET: isize>() -> Self
    {
        unsafe extern "system" fn GetLastError<
            Identity: IExchangeImportHierarchyChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportHierarchyChanges_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn Config<
            Identity: IExchangeImportHierarchyChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpstream: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportHierarchyChanges_Impl::Config(
                    this,
                    core::mem::transmute_copy(&lpstream),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn UpdateState<
            Identity: IExchangeImportHierarchyChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpstream: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportHierarchyChanges_Impl::UpdateState(
                    this,
                    core::mem::transmute_copy(&lpstream),
                )
                .into()
            }
        }
        unsafe extern "system" fn ImportFolderChange<
            Identity: IExchangeImportHierarchyChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cpvalchanges: u32,
            ppvalchanges: *mut SPropValue,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportHierarchyChanges_Impl::ImportFolderChange(
                    this,
                    core::mem::transmute_copy(&cpvalchanges),
                    core::mem::transmute_copy(&ppvalchanges),
                )
                .into()
            }
        }
        unsafe extern "system" fn ImportFolderDeletion<
            Identity: IExchangeImportHierarchyChanges_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpsrcentrylist: *mut SBinaryArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeImportHierarchyChanges_Impl::ImportFolderDeletion(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpsrcentrylist),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            Config: Config::<Identity, OFFSET>,
            UpdateState: UpdateState::<Identity, OFFSET>,
            ImportFolderChange: ImportFolderChange::<Identity, OFFSET>,
            ImportFolderDeletion: ImportFolderDeletion::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeImportHierarchyChanges as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeImportHierarchyChanges {}
windows_core::imp::define_interface!(
    IExchangeManageStore,
    IExchangeManageStore_Vtbl,
    0x559d10b0_a772_11cd_9bc8_00aa002fc45a
);
windows_core::imp::interface_hierarchy!(IExchangeManageStore, windows_core::IUnknown);
impl IExchangeManageStore {
    pub unsafe fn CreateStoreEntryID<P0, P1>(
        &self,
        lpszmsgstoredn: P0,
        lpszmailboxdn: P1,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CreateStoreEntryID)(
                windows_core::Interface::as_raw(self),
                lpszmsgstoredn.param().abi(),
                lpszmailboxdn.param().abi(),
                ulflags,
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn EntryIDFromSourceKey(
        &self,
        cfolderkeysize: u32,
        lpfoldersourcekey: *mut u8,
        cmessagekeysize: u32,
        lpmessagesourcekey: *mut u8,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).EntryIDFromSourceKey)(
                windows_core::Interface::as_raw(self),
                cfolderkeysize,
                lpfoldersourcekey as _,
                cmessagekeysize,
                lpmessagesourcekey as _,
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetRights(
        &self,
        cbuserentryid: u32,
        lpuserentryid: *mut ENTRYID,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpulrights: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetRights)(
                windows_core::Interface::as_raw(self),
                cbuserentryid,
                lpuserentryid as _,
                cbentryid,
                lpentryid as _,
                lpulrights as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMailboxTable<P0>(
        &self,
        lpszservername: P0,
        lpptable: *mut Option<IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetMailboxTable)(
                windows_core::Interface::as_raw(self),
                lpszservername.param().abi(),
                core::mem::transmute(lpptable),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetPublicFolderTable<P0>(
        &self,
        lpszservername: P0,
        lpptable: *mut Option<IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetPublicFolderTable)(
                windows_core::Interface::as_raw(self),
                lpszservername.param().abi(),
                core::mem::transmute(lpptable),
                ulflags,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeManageStore_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub CreateStoreEntryID: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        windows_core::PCSTR,
        u32,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub EntryIDFromSourceKey: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut u8,
        u32,
        *mut u8,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub GetRights: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut ENTRYID,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub GetMailboxTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub GetPublicFolderTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeManageStore_Impl: windows_core::IUnknownImpl {
    fn CreateStoreEntryID(
        &self,
        lpszmsgstoredn: &windows_core::PCSTR,
        lpszmailboxdn: &windows_core::PCSTR,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn EntryIDFromSourceKey(
        &self,
        cfolderkeysize: u32,
        lpfoldersourcekey: *mut u8,
        cmessagekeysize: u32,
        lpmessagesourcekey: *mut u8,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn GetRights(
        &self,
        cbuserentryid: u32,
        lpuserentryid: *mut ENTRYID,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpulrights: *mut u32,
    ) -> windows_core::Result<()>;
    fn GetMailboxTable(
        &self,
        lpszservername: &windows_core::PCSTR,
        lpptable: windows_core::OutRef<'_, IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn GetPublicFolderTable(
        &self,
        lpszservername: &windows_core::PCSTR,
        lpptable: windows_core::OutRef<'_, IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
}
impl IExchangeManageStore_Vtbl {
    pub const fn new<Identity: IExchangeManageStore_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn CreateStoreEntryID<
            Identity: IExchangeManageStore_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszmsgstoredn: windows_core::PCSTR,
            lpszmailboxdn: windows_core::PCSTR,
            ulflags: u32,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore_Impl::CreateStoreEntryID(
                    this,
                    core::mem::transmute(&lpszmsgstoredn),
                    core::mem::transmute(&lpszmailboxdn),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn EntryIDFromSourceKey<
            Identity: IExchangeManageStore_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cfolderkeysize: u32,
            lpfoldersourcekey: *mut u8,
            cmessagekeysize: u32,
            lpmessagesourcekey: *mut u8,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore_Impl::EntryIDFromSourceKey(
                    this,
                    core::mem::transmute_copy(&cfolderkeysize),
                    core::mem::transmute_copy(&lpfoldersourcekey),
                    core::mem::transmute_copy(&cmessagekeysize),
                    core::mem::transmute_copy(&lpmessagesourcekey),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetRights<
            Identity: IExchangeManageStore_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cbuserentryid: u32,
            lpuserentryid: *mut ENTRYID,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpulrights: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore_Impl::GetRights(
                    this,
                    core::mem::transmute_copy(&cbuserentryid),
                    core::mem::transmute_copy(&lpuserentryid),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpulrights),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMailboxTable<
            Identity: IExchangeManageStore_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservername: windows_core::PCSTR,
            lpptable: *mut *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore_Impl::GetMailboxTable(
                    this,
                    core::mem::transmute(&lpszservername),
                    core::mem::transmute_copy(&lpptable),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetPublicFolderTable<
            Identity: IExchangeManageStore_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservername: windows_core::PCSTR,
            lpptable: *mut *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore_Impl::GetPublicFolderTable(
                    this,
                    core::mem::transmute(&lpszservername),
                    core::mem::transmute_copy(&lpptable),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            CreateStoreEntryID: CreateStoreEntryID::<Identity, OFFSET>,
            EntryIDFromSourceKey: EntryIDFromSourceKey::<Identity, OFFSET>,
            GetRights: GetRights::<Identity, OFFSET>,
            GetMailboxTable: GetMailboxTable::<Identity, OFFSET>,
            GetPublicFolderTable: GetPublicFolderTable::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeManageStore as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeManageStore {}
windows_core::imp::define_interface!(
    IExchangeManageStore2,
    IExchangeManageStore2_Vtbl,
    0xb6dca470_0ff3_11d0_a409_00c04fd7bd87
);
windows_core::imp::interface_hierarchy!(IExchangeManageStore2, windows_core::IUnknown);
impl IExchangeManageStore2 {
    pub unsafe fn CreateStoreEntryID<P0, P1>(
        &self,
        lpszmsgstoredn: P0,
        lpszmailboxdn: P1,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CreateStoreEntryID)(
                windows_core::Interface::as_raw(self),
                lpszmsgstoredn.param().abi(),
                lpszmailboxdn.param().abi(),
                ulflags,
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn EntryIDFromSourceKey(
        &self,
        cfolderkeysize: u32,
        lpfoldersourcekey: *mut u8,
        cmessagekeysize: u32,
        lpmessagesourcekey: *mut u8,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).EntryIDFromSourceKey)(
                windows_core::Interface::as_raw(self),
                cfolderkeysize,
                lpfoldersourcekey as _,
                cmessagekeysize,
                lpmessagesourcekey as _,
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetRights(
        &self,
        cbuserentryid: u32,
        lpuserentryid: *mut ENTRYID,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpulrights: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetRights)(
                windows_core::Interface::as_raw(self),
                cbuserentryid,
                lpuserentryid as _,
                cbentryid,
                lpentryid as _,
                lpulrights as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMailboxTable<P0>(
        &self,
        lpszservername: P0,
        lpptable: *mut Option<IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetMailboxTable)(
                windows_core::Interface::as_raw(self),
                lpszservername.param().abi(),
                core::mem::transmute(lpptable),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetPublicFolderTable<P0>(
        &self,
        lpszservername: P0,
        lpptable: *mut Option<IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetPublicFolderTable)(
                windows_core::Interface::as_raw(self),
                lpszservername.param().abi(),
                core::mem::transmute(lpptable),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn CreateNewsgroupNameEntryID<P0>(
        &self,
        lpsznewsgroupname: P0,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CreateNewsgroupNameEntryID)(
                windows_core::Interface::as_raw(self),
                lpsznewsgroupname.param().abi(),
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeManageStore2_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub CreateStoreEntryID: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        windows_core::PCSTR,
        u32,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub EntryIDFromSourceKey: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut u8,
        u32,
        *mut u8,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub GetRights: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut ENTRYID,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub GetMailboxTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub GetPublicFolderTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub CreateNewsgroupNameEntryID: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeManageStore2_Impl: windows_core::IUnknownImpl {
    fn CreateStoreEntryID(
        &self,
        lpszmsgstoredn: &windows_core::PCSTR,
        lpszmailboxdn: &windows_core::PCSTR,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn EntryIDFromSourceKey(
        &self,
        cfolderkeysize: u32,
        lpfoldersourcekey: *mut u8,
        cmessagekeysize: u32,
        lpmessagesourcekey: *mut u8,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn GetRights(
        &self,
        cbuserentryid: u32,
        lpuserentryid: *mut ENTRYID,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpulrights: *mut u32,
    ) -> windows_core::Result<()>;
    fn GetMailboxTable(
        &self,
        lpszservername: &windows_core::PCSTR,
        lpptable: windows_core::OutRef<'_, IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn GetPublicFolderTable(
        &self,
        lpszservername: &windows_core::PCSTR,
        lpptable: windows_core::OutRef<'_, IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn CreateNewsgroupNameEntryID(
        &self,
        lpsznewsgroupname: &windows_core::PCSTR,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
}
impl IExchangeManageStore2_Vtbl {
    pub const fn new<Identity: IExchangeManageStore2_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn CreateStoreEntryID<
            Identity: IExchangeManageStore2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszmsgstoredn: windows_core::PCSTR,
            lpszmailboxdn: windows_core::PCSTR,
            ulflags: u32,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore2_Impl::CreateStoreEntryID(
                    this,
                    core::mem::transmute(&lpszmsgstoredn),
                    core::mem::transmute(&lpszmailboxdn),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn EntryIDFromSourceKey<
            Identity: IExchangeManageStore2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cfolderkeysize: u32,
            lpfoldersourcekey: *mut u8,
            cmessagekeysize: u32,
            lpmessagesourcekey: *mut u8,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore2_Impl::EntryIDFromSourceKey(
                    this,
                    core::mem::transmute_copy(&cfolderkeysize),
                    core::mem::transmute_copy(&lpfoldersourcekey),
                    core::mem::transmute_copy(&cmessagekeysize),
                    core::mem::transmute_copy(&lpmessagesourcekey),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetRights<
            Identity: IExchangeManageStore2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cbuserentryid: u32,
            lpuserentryid: *mut ENTRYID,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpulrights: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore2_Impl::GetRights(
                    this,
                    core::mem::transmute_copy(&cbuserentryid),
                    core::mem::transmute_copy(&lpuserentryid),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpulrights),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMailboxTable<
            Identity: IExchangeManageStore2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservername: windows_core::PCSTR,
            lpptable: *mut *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore2_Impl::GetMailboxTable(
                    this,
                    core::mem::transmute(&lpszservername),
                    core::mem::transmute_copy(&lpptable),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetPublicFolderTable<
            Identity: IExchangeManageStore2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservername: windows_core::PCSTR,
            lpptable: *mut *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore2_Impl::GetPublicFolderTable(
                    this,
                    core::mem::transmute(&lpszservername),
                    core::mem::transmute_copy(&lpptable),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn CreateNewsgroupNameEntryID<
            Identity: IExchangeManageStore2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpsznewsgroupname: windows_core::PCSTR,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore2_Impl::CreateNewsgroupNameEntryID(
                    this,
                    core::mem::transmute(&lpsznewsgroupname),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            CreateStoreEntryID: CreateStoreEntryID::<Identity, OFFSET>,
            EntryIDFromSourceKey: EntryIDFromSourceKey::<Identity, OFFSET>,
            GetRights: GetRights::<Identity, OFFSET>,
            GetMailboxTable: GetMailboxTable::<Identity, OFFSET>,
            GetPublicFolderTable: GetPublicFolderTable::<Identity, OFFSET>,
            CreateNewsgroupNameEntryID: CreateNewsgroupNameEntryID::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeManageStore2 as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeManageStore2 {}
windows_core::imp::define_interface!(
    IExchangeManageStore3,
    IExchangeManageStore3_Vtbl,
    0x166d9bc2_db75_44a9_8a93_9f3ffc994d76
);
windows_core::imp::interface_hierarchy!(IExchangeManageStore3, windows_core::IUnknown);
impl IExchangeManageStore3 {
    pub unsafe fn CreateStoreEntryID<P0, P1>(
        &self,
        lpszmsgstoredn: P0,
        lpszmailboxdn: P1,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CreateStoreEntryID)(
                windows_core::Interface::as_raw(self),
                lpszmsgstoredn.param().abi(),
                lpszmailboxdn.param().abi(),
                ulflags,
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn EntryIDFromSourceKey(
        &self,
        cfolderkeysize: u32,
        lpfoldersourcekey: *mut u8,
        cmessagekeysize: u32,
        lpmessagesourcekey: *mut u8,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).EntryIDFromSourceKey)(
                windows_core::Interface::as_raw(self),
                cfolderkeysize,
                lpfoldersourcekey as _,
                cmessagekeysize,
                lpmessagesourcekey as _,
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetRights(
        &self,
        cbuserentryid: u32,
        lpuserentryid: *mut ENTRYID,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpulrights: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetRights)(
                windows_core::Interface::as_raw(self),
                cbuserentryid,
                lpuserentryid as _,
                cbentryid,
                lpentryid as _,
                lpulrights as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMailboxTable<P0>(
        &self,
        lpszservername: P0,
        lpptable: *mut Option<IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetMailboxTable)(
                windows_core::Interface::as_raw(self),
                lpszservername.param().abi(),
                core::mem::transmute(lpptable),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetPublicFolderTable<P0>(
        &self,
        lpszservername: P0,
        lpptable: *mut Option<IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetPublicFolderTable)(
                windows_core::Interface::as_raw(self),
                lpszservername.param().abi(),
                core::mem::transmute(lpptable),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn CreateNewsgroupNameEntryID<P0>(
        &self,
        lpsznewsgroupname: P0,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CreateNewsgroupNameEntryID)(
                windows_core::Interface::as_raw(self),
                lpsznewsgroupname.param().abi(),
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMailboxTableOffset<P0>(
        &self,
        lpszservername: P0,
        lpptable: *mut Option<IMAPITable>,
        ulflags: u32,
        uoffset: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetMailboxTableOffset)(
                windows_core::Interface::as_raw(self),
                lpszservername.param().abi(),
                core::mem::transmute(lpptable),
                ulflags,
                uoffset,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeManageStore3_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub CreateStoreEntryID: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        windows_core::PCSTR,
        u32,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub EntryIDFromSourceKey: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut u8,
        u32,
        *mut u8,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub GetRights: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut ENTRYID,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub GetMailboxTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub GetPublicFolderTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub CreateNewsgroupNameEntryID: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub GetMailboxTableOffset: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut *mut core::ffi::c_void,
        u32,
        u32,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeManageStore3_Impl: windows_core::IUnknownImpl {
    fn CreateStoreEntryID(
        &self,
        lpszmsgstoredn: &windows_core::PCSTR,
        lpszmailboxdn: &windows_core::PCSTR,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn EntryIDFromSourceKey(
        &self,
        cfolderkeysize: u32,
        lpfoldersourcekey: *mut u8,
        cmessagekeysize: u32,
        lpmessagesourcekey: *mut u8,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn GetRights(
        &self,
        cbuserentryid: u32,
        lpuserentryid: *mut ENTRYID,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpulrights: *mut u32,
    ) -> windows_core::Result<()>;
    fn GetMailboxTable(
        &self,
        lpszservername: &windows_core::PCSTR,
        lpptable: windows_core::OutRef<'_, IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn GetPublicFolderTable(
        &self,
        lpszservername: &windows_core::PCSTR,
        lpptable: windows_core::OutRef<'_, IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn CreateNewsgroupNameEntryID(
        &self,
        lpsznewsgroupname: &windows_core::PCSTR,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn GetMailboxTableOffset(
        &self,
        lpszservername: &windows_core::PCSTR,
        lpptable: windows_core::OutRef<'_, IMAPITable>,
        ulflags: u32,
        uoffset: u32,
    ) -> windows_core::Result<()>;
}
impl IExchangeManageStore3_Vtbl {
    pub const fn new<Identity: IExchangeManageStore3_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn CreateStoreEntryID<
            Identity: IExchangeManageStore3_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszmsgstoredn: windows_core::PCSTR,
            lpszmailboxdn: windows_core::PCSTR,
            ulflags: u32,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore3_Impl::CreateStoreEntryID(
                    this,
                    core::mem::transmute(&lpszmsgstoredn),
                    core::mem::transmute(&lpszmailboxdn),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn EntryIDFromSourceKey<
            Identity: IExchangeManageStore3_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cfolderkeysize: u32,
            lpfoldersourcekey: *mut u8,
            cmessagekeysize: u32,
            lpmessagesourcekey: *mut u8,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore3_Impl::EntryIDFromSourceKey(
                    this,
                    core::mem::transmute_copy(&cfolderkeysize),
                    core::mem::transmute_copy(&lpfoldersourcekey),
                    core::mem::transmute_copy(&cmessagekeysize),
                    core::mem::transmute_copy(&lpmessagesourcekey),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetRights<
            Identity: IExchangeManageStore3_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cbuserentryid: u32,
            lpuserentryid: *mut ENTRYID,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpulrights: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore3_Impl::GetRights(
                    this,
                    core::mem::transmute_copy(&cbuserentryid),
                    core::mem::transmute_copy(&lpuserentryid),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpulrights),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMailboxTable<
            Identity: IExchangeManageStore3_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservername: windows_core::PCSTR,
            lpptable: *mut *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore3_Impl::GetMailboxTable(
                    this,
                    core::mem::transmute(&lpszservername),
                    core::mem::transmute_copy(&lpptable),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetPublicFolderTable<
            Identity: IExchangeManageStore3_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservername: windows_core::PCSTR,
            lpptable: *mut *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore3_Impl::GetPublicFolderTable(
                    this,
                    core::mem::transmute(&lpszservername),
                    core::mem::transmute_copy(&lpptable),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn CreateNewsgroupNameEntryID<
            Identity: IExchangeManageStore3_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpsznewsgroupname: windows_core::PCSTR,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore3_Impl::CreateNewsgroupNameEntryID(
                    this,
                    core::mem::transmute(&lpsznewsgroupname),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMailboxTableOffset<
            Identity: IExchangeManageStore3_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservername: windows_core::PCSTR,
            lpptable: *mut *mut core::ffi::c_void,
            ulflags: u32,
            uoffset: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore3_Impl::GetMailboxTableOffset(
                    this,
                    core::mem::transmute(&lpszservername),
                    core::mem::transmute_copy(&lpptable),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&uoffset),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            CreateStoreEntryID: CreateStoreEntryID::<Identity, OFFSET>,
            EntryIDFromSourceKey: EntryIDFromSourceKey::<Identity, OFFSET>,
            GetRights: GetRights::<Identity, OFFSET>,
            GetMailboxTable: GetMailboxTable::<Identity, OFFSET>,
            GetPublicFolderTable: GetPublicFolderTable::<Identity, OFFSET>,
            CreateNewsgroupNameEntryID: CreateNewsgroupNameEntryID::<Identity, OFFSET>,
            GetMailboxTableOffset: GetMailboxTableOffset::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeManageStore3 as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeManageStore3 {}
windows_core::imp::define_interface!(
    IExchangeManageStore4,
    IExchangeManageStore4_Vtbl,
    0x2590ff87_c431_4f9c_b1a8_cd69d760cd10
);
windows_core::imp::interface_hierarchy!(IExchangeManageStore4, windows_core::IUnknown);
impl IExchangeManageStore4 {
    pub unsafe fn CreateStoreEntryID<P0, P1>(
        &self,
        lpszmsgstoredn: P0,
        lpszmailboxdn: P1,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CreateStoreEntryID)(
                windows_core::Interface::as_raw(self),
                lpszmsgstoredn.param().abi(),
                lpszmailboxdn.param().abi(),
                ulflags,
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn EntryIDFromSourceKey(
        &self,
        cfolderkeysize: u32,
        lpfoldersourcekey: *mut u8,
        cmessagekeysize: u32,
        lpmessagesourcekey: *mut u8,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).EntryIDFromSourceKey)(
                windows_core::Interface::as_raw(self),
                cfolderkeysize,
                lpfoldersourcekey as _,
                cmessagekeysize,
                lpmessagesourcekey as _,
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetRights(
        &self,
        cbuserentryid: u32,
        lpuserentryid: *mut ENTRYID,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpulrights: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetRights)(
                windows_core::Interface::as_raw(self),
                cbuserentryid,
                lpuserentryid as _,
                cbentryid,
                lpentryid as _,
                lpulrights as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMailboxTable<P0>(
        &self,
        lpszservername: P0,
        lpptable: *mut Option<IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetMailboxTable)(
                windows_core::Interface::as_raw(self),
                lpszservername.param().abi(),
                core::mem::transmute(lpptable),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetPublicFolderTable<P0>(
        &self,
        lpszservername: P0,
        lpptable: *mut Option<IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetPublicFolderTable)(
                windows_core::Interface::as_raw(self),
                lpszservername.param().abi(),
                core::mem::transmute(lpptable),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn CreateNewsgroupNameEntryID<P0>(
        &self,
        lpsznewsgroupname: P0,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CreateNewsgroupNameEntryID)(
                windows_core::Interface::as_raw(self),
                lpsznewsgroupname.param().abi(),
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMailboxTableOffset<P0>(
        &self,
        lpszservername: P0,
        lpptable: *mut Option<IMAPITable>,
        ulflags: u32,
        uoffset: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetMailboxTableOffset)(
                windows_core::Interface::as_raw(self),
                lpszservername.param().abi(),
                core::mem::transmute(lpptable),
                ulflags,
                uoffset,
            )
            .ok()
        }
    }
    pub unsafe fn GetPublicFolderTableOffset<P0>(
        &self,
        lpszservername: P0,
        lpptable: *mut Option<IMAPITable>,
        ulflags: u32,
        uoffset: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetPublicFolderTableOffset)(
                windows_core::Interface::as_raw(self),
                lpszservername.param().abi(),
                core::mem::transmute(lpptable),
                ulflags,
                uoffset,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeManageStore4_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub CreateStoreEntryID: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        windows_core::PCSTR,
        u32,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub EntryIDFromSourceKey: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut u8,
        u32,
        *mut u8,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub GetRights: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut ENTRYID,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub GetMailboxTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub GetPublicFolderTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub CreateNewsgroupNameEntryID: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub GetMailboxTableOffset: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut *mut core::ffi::c_void,
        u32,
        u32,
    ) -> windows_core::HRESULT,
    pub GetPublicFolderTableOffset: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut *mut core::ffi::c_void,
        u32,
        u32,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeManageStore4_Impl: windows_core::IUnknownImpl {
    fn CreateStoreEntryID(
        &self,
        lpszmsgstoredn: &windows_core::PCSTR,
        lpszmailboxdn: &windows_core::PCSTR,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn EntryIDFromSourceKey(
        &self,
        cfolderkeysize: u32,
        lpfoldersourcekey: *mut u8,
        cmessagekeysize: u32,
        lpmessagesourcekey: *mut u8,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn GetRights(
        &self,
        cbuserentryid: u32,
        lpuserentryid: *mut ENTRYID,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpulrights: *mut u32,
    ) -> windows_core::Result<()>;
    fn GetMailboxTable(
        &self,
        lpszservername: &windows_core::PCSTR,
        lpptable: windows_core::OutRef<'_, IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn GetPublicFolderTable(
        &self,
        lpszservername: &windows_core::PCSTR,
        lpptable: windows_core::OutRef<'_, IMAPITable>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn CreateNewsgroupNameEntryID(
        &self,
        lpsznewsgroupname: &windows_core::PCSTR,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn GetMailboxTableOffset(
        &self,
        lpszservername: &windows_core::PCSTR,
        lpptable: windows_core::OutRef<'_, IMAPITable>,
        ulflags: u32,
        uoffset: u32,
    ) -> windows_core::Result<()>;
    fn GetPublicFolderTableOffset(
        &self,
        lpszservername: &windows_core::PCSTR,
        lpptable: windows_core::OutRef<'_, IMAPITable>,
        ulflags: u32,
        uoffset: u32,
    ) -> windows_core::Result<()>;
}
impl IExchangeManageStore4_Vtbl {
    pub const fn new<Identity: IExchangeManageStore4_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn CreateStoreEntryID<
            Identity: IExchangeManageStore4_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszmsgstoredn: windows_core::PCSTR,
            lpszmailboxdn: windows_core::PCSTR,
            ulflags: u32,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore4_Impl::CreateStoreEntryID(
                    this,
                    core::mem::transmute(&lpszmsgstoredn),
                    core::mem::transmute(&lpszmailboxdn),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn EntryIDFromSourceKey<
            Identity: IExchangeManageStore4_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cfolderkeysize: u32,
            lpfoldersourcekey: *mut u8,
            cmessagekeysize: u32,
            lpmessagesourcekey: *mut u8,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore4_Impl::EntryIDFromSourceKey(
                    this,
                    core::mem::transmute_copy(&cfolderkeysize),
                    core::mem::transmute_copy(&lpfoldersourcekey),
                    core::mem::transmute_copy(&cmessagekeysize),
                    core::mem::transmute_copy(&lpmessagesourcekey),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetRights<
            Identity: IExchangeManageStore4_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cbuserentryid: u32,
            lpuserentryid: *mut ENTRYID,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpulrights: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore4_Impl::GetRights(
                    this,
                    core::mem::transmute_copy(&cbuserentryid),
                    core::mem::transmute_copy(&lpuserentryid),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpulrights),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMailboxTable<
            Identity: IExchangeManageStore4_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservername: windows_core::PCSTR,
            lpptable: *mut *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore4_Impl::GetMailboxTable(
                    this,
                    core::mem::transmute(&lpszservername),
                    core::mem::transmute_copy(&lpptable),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetPublicFolderTable<
            Identity: IExchangeManageStore4_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservername: windows_core::PCSTR,
            lpptable: *mut *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore4_Impl::GetPublicFolderTable(
                    this,
                    core::mem::transmute(&lpszservername),
                    core::mem::transmute_copy(&lpptable),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn CreateNewsgroupNameEntryID<
            Identity: IExchangeManageStore4_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpsznewsgroupname: windows_core::PCSTR,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore4_Impl::CreateNewsgroupNameEntryID(
                    this,
                    core::mem::transmute(&lpsznewsgroupname),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMailboxTableOffset<
            Identity: IExchangeManageStore4_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservername: windows_core::PCSTR,
            lpptable: *mut *mut core::ffi::c_void,
            ulflags: u32,
            uoffset: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore4_Impl::GetMailboxTableOffset(
                    this,
                    core::mem::transmute(&lpszservername),
                    core::mem::transmute_copy(&lpptable),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&uoffset),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetPublicFolderTableOffset<
            Identity: IExchangeManageStore4_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservername: windows_core::PCSTR,
            lpptable: *mut *mut core::ffi::c_void,
            ulflags: u32,
            uoffset: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeManageStore4_Impl::GetPublicFolderTableOffset(
                    this,
                    core::mem::transmute(&lpszservername),
                    core::mem::transmute_copy(&lpptable),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&uoffset),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            CreateStoreEntryID: CreateStoreEntryID::<Identity, OFFSET>,
            EntryIDFromSourceKey: EntryIDFromSourceKey::<Identity, OFFSET>,
            GetRights: GetRights::<Identity, OFFSET>,
            GetMailboxTable: GetMailboxTable::<Identity, OFFSET>,
            GetPublicFolderTable: GetPublicFolderTable::<Identity, OFFSET>,
            CreateNewsgroupNameEntryID: CreateNewsgroupNameEntryID::<Identity, OFFSET>,
            GetMailboxTableOffset: GetMailboxTableOffset::<Identity, OFFSET>,
            GetPublicFolderTableOffset: GetPublicFolderTableOffset::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeManageStore4 as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeManageStore4 {}
windows_core::imp::define_interface!(
    IExchangeMessageConversion,
    IExchangeMessageConversion_Vtbl,
    0x3532b360_d114_11cf_a83b_00c04fd65597
);
windows_core::imp::interface_hierarchy!(IExchangeMessageConversion, windows_core::IUnknown);
impl IExchangeMessageConversion {
    pub unsafe fn OpenStream(
        &self,
        cvalues: u32,
        lpproparray: *mut SPropValue,
        lppstream: *mut Option<windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenStream)(
                windows_core::Interface::as_raw(self),
                cvalues,
                lpproparray as _,
                core::mem::transmute(lppstream),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeMessageConversion_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub OpenStream: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut SPropValue,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeMessageConversion_Impl: windows_core::IUnknownImpl {
    fn OpenStream(
        &self,
        cvalues: u32,
        lpproparray: *mut SPropValue,
        lppstream: windows_core::OutRef<'_, windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()>;
}
impl IExchangeMessageConversion_Vtbl {
    pub const fn new<Identity: IExchangeMessageConversion_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn OpenStream<
            Identity: IExchangeMessageConversion_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cvalues: u32,
            lpproparray: *mut SPropValue,
            lppstream: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeMessageConversion_Impl::OpenStream(
                    this,
                    core::mem::transmute_copy(&cvalues),
                    core::mem::transmute_copy(&lpproparray),
                    core::mem::transmute_copy(&lppstream),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            OpenStream: OpenStream::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeMessageConversion as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeMessageConversion {}
windows_core::imp::define_interface!(
    IExchangeModifyTable,
    IExchangeModifyTable_Vtbl,
    0x2d734cb0_53fd_101b_b19d_08002b3056e3
);
windows_core::imp::interface_hierarchy!(IExchangeModifyTable, windows_core::IUnknown);
impl IExchangeModifyTable {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn ModifyTable(
        &self,
        ulflags: u32,
        lpmods: *mut ROWLIST,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ModifyTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpmods as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeModifyTable_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub GetTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ModifyTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ROWLIST,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeModifyTable_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn GetTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn ModifyTable(&self, ulflags: u32, lpmods: *mut ROWLIST) -> windows_core::Result<()>;
}
impl IExchangeModifyTable_Vtbl {
    pub const fn new<Identity: IExchangeModifyTable_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IExchangeModifyTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeModifyTable_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetTable<
            Identity: IExchangeModifyTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IExchangeModifyTable_Impl::GetTable(this, core::mem::transmute_copy(&ulflags))
                {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn ModifyTable<
            Identity: IExchangeModifyTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpmods: *mut ROWLIST,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeModifyTable_Impl::ModifyTable(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpmods),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            GetTable: GetTable::<Identity, OFFSET>,
            ModifyTable: ModifyTable::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeModifyTable as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeModifyTable {}
windows_core::imp::define_interface!(
    IExchangeMoveUserProgress,
    IExchangeMoveUserProgress_Vtbl,
    0xef2fb44a_8dac_4e4e_b1e3_a3b926355617
);
windows_core::imp::interface_hierarchy!(IExchangeMoveUserProgress, windows_core::IUnknown);
impl IExchangeMoveUserProgress {
    pub unsafe fn NextFolder<P1>(
        &self,
        ulflags: u32,
        lpwszfoldername: P1,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows_core::PCWSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).NextFolder)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpwszfoldername.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn Progress(
        &self,
        ulflags: u32,
        ulcount: u32,
        ultotal: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Progress)(
                windows_core::Interface::as_raw(self),
                ulflags,
                ulcount,
                ultotal,
            )
            .ok()
        }
    }
    pub unsafe fn Restart(&self, ulflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Restart)(
                windows_core::Interface::as_raw(self),
                ulflags,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeMoveUserProgress_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub NextFolder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        windows_core::PCWSTR,
    ) -> windows_core::HRESULT,
    pub Progress:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32, u32) -> windows_core::HRESULT,
    pub Restart: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
}
pub trait IExchangeMoveUserProgress_Impl: windows_core::IUnknownImpl {
    fn NextFolder(
        &self,
        ulflags: u32,
        lpwszfoldername: &windows_core::PCWSTR,
    ) -> windows_core::Result<()>;
    fn Progress(&self, ulflags: u32, ulcount: u32, ultotal: u32) -> windows_core::Result<()>;
    fn Restart(&self, ulflags: u32) -> windows_core::Result<()>;
}
impl IExchangeMoveUserProgress_Vtbl {
    pub const fn new<Identity: IExchangeMoveUserProgress_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn NextFolder<
            Identity: IExchangeMoveUserProgress_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpwszfoldername: windows_core::PCWSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeMoveUserProgress_Impl::NextFolder(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute(&lpwszfoldername),
                )
                .into()
            }
        }
        unsafe extern "system" fn Progress<
            Identity: IExchangeMoveUserProgress_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            ulcount: u32,
            ultotal: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeMoveUserProgress_Impl::Progress(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&ulcount),
                    core::mem::transmute_copy(&ultotal),
                )
                .into()
            }
        }
        unsafe extern "system" fn Restart<
            Identity: IExchangeMoveUserProgress_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeMoveUserProgress_Impl::Restart(this, core::mem::transmute_copy(&ulflags))
                    .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            NextFolder: NextFolder::<Identity, OFFSET>,
            Progress: Progress::<Identity, OFFSET>,
            Restart: Restart::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeMoveUserProgress as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeMoveUserProgress {}
windows_core::imp::define_interface!(
    IExchangeNntpNewsfeed,
    IExchangeNntpNewsfeed_Vtbl,
    0x380f41c0_3cdc_11d0_9792_00c04fd6551d
);
windows_core::imp::interface_hierarchy!(IExchangeNntpNewsfeed, windows_core::IUnknown);
impl IExchangeNntpNewsfeed {
    pub unsafe fn Configure<P0>(
        &self,
        lpsznewsfeeddn: P0,
        cvalues: u32,
        lpimailproparray: *mut SPropValue,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Configure)(
                windows_core::Interface::as_raw(self),
                lpsznewsfeeddn.param().abi(),
                cvalues,
                lpimailproparray as _,
            )
            .ok()
        }
    }
    pub unsafe fn CheckMsgIds<P0>(
        &self,
        lpszmsgids: P0,
        lpcfwanted: *mut u32,
        lppfwanted: *mut *mut u8,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CheckMsgIds)(
                windows_core::Interface::as_raw(self),
                lpszmsgids.param().abi(),
                lpcfwanted as _,
                lppfwanted as _,
            )
            .ok()
        }
    }
    pub unsafe fn OpenArticleStream(
        &self,
    ) -> windows_core::Result<windows::Win32::System::Com::IStream> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).OpenArticleStream)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
}
#[repr(C)]
pub struct IExchangeNntpNewsfeed_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Configure: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        u32,
        *mut SPropValue,
    ) -> windows_core::HRESULT,
    pub CheckMsgIds: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut u32,
        *mut *mut u8,
    ) -> windows_core::HRESULT,
    pub OpenArticleStream: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeNntpNewsfeed_Impl: windows_core::IUnknownImpl {
    fn Configure(
        &self,
        lpsznewsfeeddn: &windows_core::PCSTR,
        cvalues: u32,
        lpimailproparray: *mut SPropValue,
    ) -> windows_core::Result<()>;
    fn CheckMsgIds(
        &self,
        lpszmsgids: &windows_core::PCSTR,
        lpcfwanted: *mut u32,
        lppfwanted: *mut *mut u8,
    ) -> windows_core::Result<()>;
    fn OpenArticleStream(&self) -> windows_core::Result<windows::Win32::System::Com::IStream>;
}
impl IExchangeNntpNewsfeed_Vtbl {
    pub const fn new<Identity: IExchangeNntpNewsfeed_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Configure<
            Identity: IExchangeNntpNewsfeed_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpsznewsfeeddn: windows_core::PCSTR,
            cvalues: u32,
            lpimailproparray: *mut SPropValue,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeNntpNewsfeed_Impl::Configure(
                    this,
                    core::mem::transmute(&lpsznewsfeeddn),
                    core::mem::transmute_copy(&cvalues),
                    core::mem::transmute_copy(&lpimailproparray),
                )
                .into()
            }
        }
        unsafe extern "system" fn CheckMsgIds<
            Identity: IExchangeNntpNewsfeed_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszmsgids: windows_core::PCSTR,
            lpcfwanted: *mut u32,
            lppfwanted: *mut *mut u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeNntpNewsfeed_Impl::CheckMsgIds(
                    this,
                    core::mem::transmute(&lpszmsgids),
                    core::mem::transmute_copy(&lpcfwanted),
                    core::mem::transmute_copy(&lppfwanted),
                )
                .into()
            }
        }
        unsafe extern "system" fn OpenArticleStream<
            Identity: IExchangeNntpNewsfeed_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lppstream: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IExchangeNntpNewsfeed_Impl::OpenArticleStream(this) {
                    Ok(ok__) => {
                        lppstream.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Configure: Configure::<Identity, OFFSET>,
            CheckMsgIds: CheckMsgIds::<Identity, OFFSET>,
            OpenArticleStream: OpenArticleStream::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeNntpNewsfeed as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeNntpNewsfeed {}
windows_core::imp::define_interface!(
    IExchangeRuleAction,
    IExchangeRuleAction_Vtbl,
    0x74bba840_c93a_11ce_9581_00aa005742f7
);
windows_core::imp::interface_hierarchy!(IExchangeRuleAction, windows_core::IUnknown);
impl IExchangeRuleAction {
    pub unsafe fn ActionCount(&self, lpcactions: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ActionCount)(
                windows_core::Interface::as_raw(self),
                lpcactions as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetAction(
        &self,
        ulactionnumber: u32,
        lpruleid: *mut i64,
        lppaction: *mut *mut ACTION,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetAction)(
                windows_core::Interface::as_raw(self),
                ulactionnumber,
                lpruleid as _,
                lppaction as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IExchangeRuleAction_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub ActionCount:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub GetAction: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut i64,
        *mut *mut ACTION,
    ) -> windows_core::HRESULT,
}
pub trait IExchangeRuleAction_Impl: windows_core::IUnknownImpl {
    fn ActionCount(&self, lpcactions: *mut u32) -> windows_core::Result<()>;
    fn GetAction(
        &self,
        ulactionnumber: u32,
        lpruleid: *mut i64,
        lppaction: *mut *mut ACTION,
    ) -> windows_core::Result<()>;
}
impl IExchangeRuleAction_Vtbl {
    pub const fn new<Identity: IExchangeRuleAction_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn ActionCount<
            Identity: IExchangeRuleAction_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpcactions: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeRuleAction_Impl::ActionCount(this, core::mem::transmute_copy(&lpcactions))
                    .into()
            }
        }
        unsafe extern "system" fn GetAction<
            Identity: IExchangeRuleAction_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulactionnumber: u32,
            lpruleid: *mut i64,
            lppaction: *mut *mut ACTION,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IExchangeRuleAction_Impl::GetAction(
                    this,
                    core::mem::transmute_copy(&ulactionnumber),
                    core::mem::transmute_copy(&lpruleid),
                    core::mem::transmute_copy(&lppaction),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            ActionCount: ActionCount::<Identity, OFFSET>,
            GetAction: GetAction::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IExchangeRuleAction as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IExchangeRuleAction {}
windows_core::imp::define_interface!(
    IFontCache,
    IFontCache_Vtbl,
    0xb0d17fc2_7bc4_11d1_bdfa_00c04fa31009
);
windows_core::imp::interface_hierarchy!(IFontCache, windows_core::IUnknown);
impl IFontCache {
    pub unsafe fn Init<P1>(
        &self,
        hkey: windows::Win32::System::Registry::HKEY,
        pszintlkey: P1,
        dwflags: u32,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Init)(
                windows_core::Interface::as_raw(self),
                hkey,
                pszintlkey.param().abi(),
                dwflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetFont(
        &self,
        fnttype: FNTSYSTYPE,
        hcharset: *mut HCHARSET__,
        phfont: *mut windows::Win32::Graphics::Gdi::HFONT,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetFont)(
                windows_core::Interface::as_raw(self),
                fnttype,
                hcharset as _,
                phfont as _,
            )
            .ok()
        }
    }
    pub unsafe fn OnOptionChange(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OnOptionChange)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn GetJP_ISOControl(
        &self,
        pfusesio: *mut windows_core::BOOL,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetJP_ISOControl)(
                windows_core::Interface::as_raw(self),
                pfusesio as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IFontCache_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Init: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows::Win32::System::Registry::HKEY,
        windows_core::PCSTR,
        u32,
    ) -> windows_core::HRESULT,
    pub GetFont: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        FNTSYSTYPE,
        *mut HCHARSET__,
        *mut windows::Win32::Graphics::Gdi::HFONT,
    ) -> windows_core::HRESULT,
    pub OnOptionChange: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub GetJP_ISOControl: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::BOOL,
    ) -> windows_core::HRESULT,
}
pub trait IFontCache_Impl: windows_core::IUnknownImpl {
    fn Init(
        &self,
        hkey: windows::Win32::System::Registry::HKEY,
        pszintlkey: &windows_core::PCSTR,
        dwflags: u32,
    ) -> windows_core::Result<()>;
    fn GetFont(
        &self,
        fnttype: FNTSYSTYPE,
        hcharset: *mut HCHARSET__,
        phfont: *mut windows::Win32::Graphics::Gdi::HFONT,
    ) -> windows_core::Result<()>;
    fn OnOptionChange(&self) -> windows_core::Result<()>;
    fn GetJP_ISOControl(&self, pfusesio: *mut windows_core::BOOL) -> windows_core::Result<()>;
}
impl IFontCache_Vtbl {
    pub const fn new<Identity: IFontCache_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Init<Identity: IFontCache_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            hkey: windows::Win32::System::Registry::HKEY,
            pszintlkey: windows_core::PCSTR,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IFontCache_Impl::Init(
                    this,
                    core::mem::transmute_copy(&hkey),
                    core::mem::transmute(&pszintlkey),
                    core::mem::transmute_copy(&dwflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetFont<Identity: IFontCache_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            fnttype: FNTSYSTYPE,
            hcharset: *mut HCHARSET__,
            phfont: *mut windows::Win32::Graphics::Gdi::HFONT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IFontCache_Impl::GetFont(
                    this,
                    core::mem::transmute_copy(&fnttype),
                    core::mem::transmute_copy(&hcharset),
                    core::mem::transmute_copy(&phfont),
                )
                .into()
            }
        }
        unsafe extern "system" fn OnOptionChange<Identity: IFontCache_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IFontCache_Impl::OnOptionChange(this).into()
            }
        }
        unsafe extern "system" fn GetJP_ISOControl<
            Identity: IFontCache_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pfusesio: *mut windows_core::BOOL,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IFontCache_Impl::GetJP_ISOControl(this, core::mem::transmute_copy(&pfusesio)).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Init: Init::<Identity, OFFSET>,
            GetFont: GetFont::<Identity, OFFSET>,
            OnOptionChange: OnOptionChange::<Identity, OFFSET>,
            GetJP_ISOControl: GetJP_ISOControl::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IFontCache as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IFontCache {}
windows_core::imp::define_interface!(
    IFontCacheNotify,
    IFontCacheNotify_Vtbl,
    0xb0d17fc5_7bc4_11d1_bdfa_00c04fa31009
);
windows_core::imp::interface_hierarchy!(IFontCacheNotify, windows_core::IUnknown);
impl IFontCacheNotify {
    pub unsafe fn OnPreFontChange(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OnPreFontChange)(
                windows_core::Interface::as_raw(self),
            )
            .ok()
        }
    }
    pub unsafe fn OnPostFontChange(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OnPostFontChange)(
                windows_core::Interface::as_raw(self),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IFontCacheNotify_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub OnPreFontChange: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub OnPostFontChange:
        unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IFontCacheNotify_Impl: windows_core::IUnknownImpl {
    fn OnPreFontChange(&self) -> windows_core::Result<()>;
    fn OnPostFontChange(&self) -> windows_core::Result<()>;
}
impl IFontCacheNotify_Vtbl {
    pub const fn new<Identity: IFontCacheNotify_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn OnPreFontChange<
            Identity: IFontCacheNotify_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IFontCacheNotify_Impl::OnPreFontChange(this).into()
            }
        }
        unsafe extern "system" fn OnPostFontChange<
            Identity: IFontCacheNotify_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IFontCacheNotify_Impl::OnPostFontChange(this).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            OnPreFontChange: OnPreFontChange::<Identity, OFFSET>,
            OnPostFontChange: OnPostFontChange::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IFontCacheNotify as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IFontCacheNotify {}
windows_core::imp::define_interface!(
    IHashTable,
    IHashTable_Vtbl,
    0x64577981_86d7_11d1_bdfc_00c04fa31009
);
windows_core::imp::interface_hierarchy!(IHashTable, windows_core::IUnknown);
impl IHashTable {
    pub unsafe fn Init(&self, dwsize: u32, fdupekeys: bool) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Init)(
                windows_core::Interface::as_raw(self),
                dwsize,
                fdupekeys.into(),
            )
            .ok()
        }
    }
    pub unsafe fn Insert<P0>(
        &self,
        psz: P0,
        pv: *mut core::ffi::c_void,
        dwflags: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Insert)(
                windows_core::Interface::as_raw(self),
                psz.param().abi(),
                pv as _,
                dwflags,
            )
            .ok()
        }
    }
    pub unsafe fn Replace<P0>(
        &self,
        psz: P0,
        pv: *mut core::ffi::c_void,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Replace)(
                windows_core::Interface::as_raw(self),
                psz.param().abi(),
                pv as _,
            )
            .ok()
        }
    }
    pub unsafe fn Find<P0>(
        &self,
        psz: P0,
        fremove: bool,
        ppv: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Find)(
                windows_core::Interface::as_raw(self),
                psz.param().abi(),
                fremove.into(),
                ppv as _,
            )
            .ok()
        }
    }
    pub unsafe fn Reset(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn Next(
        &self,
        cfetch: u32,
        prgpv: *mut *mut *mut core::ffi::c_void,
        pcfetched: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Next)(
                windows_core::Interface::as_raw(self),
                cfetch,
                prgpv as _,
                pcfetched as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IHashTable_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Init: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        windows_core::BOOL,
    ) -> windows_core::HRESULT,
    pub Insert: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub Replace: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Find: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        windows_core::BOOL,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub Next: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut *mut core::ffi::c_void,
        *mut u32,
    ) -> windows_core::HRESULT,
}
pub trait IHashTable_Impl: windows_core::IUnknownImpl {
    fn Init(&self, dwsize: u32, fdupekeys: windows_core::BOOL) -> windows_core::Result<()>;
    fn Insert(
        &self,
        psz: &windows_core::PCSTR,
        pv: *mut core::ffi::c_void,
        dwflags: u32,
    ) -> windows_core::Result<()>;
    fn Replace(
        &self,
        psz: &windows_core::PCSTR,
        pv: *mut core::ffi::c_void,
    ) -> windows_core::Result<()>;
    fn Find(
        &self,
        psz: &windows_core::PCSTR,
        fremove: windows_core::BOOL,
        ppv: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()>;
    fn Reset(&self) -> windows_core::Result<()>;
    fn Next(
        &self,
        cfetch: u32,
        prgpv: *mut *mut *mut core::ffi::c_void,
        pcfetched: *mut u32,
    ) -> windows_core::Result<()>;
}
impl IHashTable_Vtbl {
    pub const fn new<Identity: IHashTable_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Init<Identity: IHashTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            dwsize: u32,
            fdupekeys: windows_core::BOOL,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IHashTable_Impl::Init(
                    this,
                    core::mem::transmute_copy(&dwsize),
                    core::mem::transmute_copy(&fdupekeys),
                )
                .into()
            }
        }
        unsafe extern "system" fn Insert<Identity: IHashTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            psz: windows_core::PCSTR,
            pv: *mut core::ffi::c_void,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IHashTable_Impl::Insert(
                    this,
                    core::mem::transmute(&psz),
                    core::mem::transmute_copy(&pv),
                    core::mem::transmute_copy(&dwflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn Replace<Identity: IHashTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            psz: windows_core::PCSTR,
            pv: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IHashTable_Impl::Replace(
                    this,
                    core::mem::transmute(&psz),
                    core::mem::transmute_copy(&pv),
                )
                .into()
            }
        }
        unsafe extern "system" fn Find<Identity: IHashTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            psz: windows_core::PCSTR,
            fremove: windows_core::BOOL,
            ppv: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IHashTable_Impl::Find(
                    this,
                    core::mem::transmute(&psz),
                    core::mem::transmute_copy(&fremove),
                    core::mem::transmute_copy(&ppv),
                )
                .into()
            }
        }
        unsafe extern "system" fn Reset<Identity: IHashTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IHashTable_Impl::Reset(this).into()
            }
        }
        unsafe extern "system" fn Next<Identity: IHashTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cfetch: u32,
            prgpv: *mut *mut *mut core::ffi::c_void,
            pcfetched: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IHashTable_Impl::Next(
                    this,
                    core::mem::transmute_copy(&cfetch),
                    core::mem::transmute_copy(&prgpv),
                    core::mem::transmute_copy(&pcfetched),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Init: Init::<Identity, OFFSET>,
            Insert: Insert::<Identity, OFFSET>,
            Replace: Replace::<Identity, OFFSET>,
            Find: Find::<Identity, OFFSET>,
            Reset: Reset::<Identity, OFFSET>,
            Next: Next::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IHashTable as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IHashTable {}
pub const ILM_BODYCSET: INETLANGMASK = INETLANGMASK(4i32);
pub const ILM_FAMILY: INETLANGMASK = INETLANGMASK(1i32);
pub const ILM_FIXEDFONT: INETLANGMASK = INETLANGMASK(32i32);
pub const ILM_HEADERCSET: INETLANGMASK = INETLANGMASK(8i32);
pub const ILM_NAME: INETLANGMASK = INETLANGMASK(2i32);
pub const ILM_VARIABLEFONT: INETLANGMASK = INETLANGMASK(64i32);
pub const ILM_WEBCSET: INETLANGMASK = INETLANGMASK(16i32);
windows_core::imp::define_interface!(
    IMAPIAdviseSink,
    IMAPIAdviseSink_Vtbl,
    0x00020302_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIAdviseSink, windows_core::IUnknown);
impl IMAPIAdviseSink {
    pub unsafe fn OnNotify(&self, cnotif: u32, lpnotifications: *mut NOTIFICATION) -> u32 {
        unsafe {
            (windows_core::Interface::vtable(self).OnNotify)(
                windows_core::Interface::as_raw(self),
                cnotif,
                lpnotifications as _,
            )
        }
    }
}
#[repr(C)]
pub struct IMAPIAdviseSink_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub OnNotify: unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut NOTIFICATION) -> u32,
}
pub trait IMAPIAdviseSink_Impl: windows_core::IUnknownImpl {
    fn OnNotify(&self, cnotif: u32, lpnotifications: *mut NOTIFICATION) -> u32;
}
impl IMAPIAdviseSink_Vtbl {
    pub const fn new<Identity: IMAPIAdviseSink_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn OnNotify<Identity: IMAPIAdviseSink_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cnotif: u32,
            lpnotifications: *mut NOTIFICATION,
        ) -> u32 {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIAdviseSink_Impl::OnNotify(
                    this,
                    core::mem::transmute_copy(&cnotif),
                    core::mem::transmute_copy(&lpnotifications),
                )
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            OnNotify: OnNotify::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIAdviseSink as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIAdviseSink {}
pub const IMAPIAdviseSink_OnNotify: METHODS = METHODS(137i32);
windows_core::imp::define_interface!(
    IMAPIClientShutdown,
    IMAPIClientShutdown_Vtbl,
    0x00020397_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIClientShutdown, windows_core::IUnknown);
impl IMAPIClientShutdown {
    pub unsafe fn QueryFastShutdown(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).QueryFastShutdown)(
                windows_core::Interface::as_raw(self),
            )
            .ok()
        }
    }
    pub unsafe fn NotifyProcessShutdown(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).NotifyProcessShutdown)(
                windows_core::Interface::as_raw(self),
            )
            .ok()
        }
    }
    pub unsafe fn DoFastShutdown(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DoFastShutdown)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIClientShutdown_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub QueryFastShutdown:
        unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub NotifyProcessShutdown:
        unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub DoFastShutdown: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IMAPIClientShutdown_Impl: windows_core::IUnknownImpl {
    fn QueryFastShutdown(&self) -> windows_core::Result<()>;
    fn NotifyProcessShutdown(&self) -> windows_core::Result<()>;
    fn DoFastShutdown(&self) -> windows_core::Result<()>;
}
impl IMAPIClientShutdown_Vtbl {
    pub const fn new<Identity: IMAPIClientShutdown_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn QueryFastShutdown<
            Identity: IMAPIClientShutdown_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIClientShutdown_Impl::QueryFastShutdown(this).into()
            }
        }
        unsafe extern "system" fn NotifyProcessShutdown<
            Identity: IMAPIClientShutdown_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIClientShutdown_Impl::NotifyProcessShutdown(this).into()
            }
        }
        unsafe extern "system" fn DoFastShutdown<
            Identity: IMAPIClientShutdown_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIClientShutdown_Impl::DoFastShutdown(this).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            QueryFastShutdown: QueryFastShutdown::<Identity, OFFSET>,
            NotifyProcessShutdown: NotifyProcessShutdown::<Identity, OFFSET>,
            DoFastShutdown: DoFastShutdown::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIClientShutdown as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIClientShutdown {}
windows_core::imp::define_interface!(
    IMAPIContainer,
    IMAPIContainer_Vtbl,
    0x0002030b_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMAPIContainer {
    type Target = IMAPIProp;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(IMAPIContainer, windows_core::IUnknown, IMAPIProp);
impl IMAPIContainer {
    pub unsafe fn GetContentsTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetContentsTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn GetHierarchyTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetHierarchyTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppunk: *mut Option<windows_core::IUnknown>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenEntry)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                lpinterface as _,
                ulflags,
                lpulobjtype as _,
                core::mem::transmute(lppunk),
            )
            .ok()
        }
    }
    pub unsafe fn SetSearchCriteria(
        &self,
        lprestriction: *mut SRestriction,
        lpcontainerlist: *mut SBinaryArray,
        ulsearchflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetSearchCriteria)(
                windows_core::Interface::as_raw(self),
                lprestriction as _,
                lpcontainerlist as _,
                ulsearchflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetSearchCriteria(
        &self,
        ulflags: u32,
        lpprestriction: *mut *mut SRestriction,
        lppcontainerlist: *mut *mut SBinaryArray,
        lpulsearchstate: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetSearchCriteria)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpprestriction as _,
                lppcontainerlist as _,
                lpulsearchstate as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIContainer_Vtbl {
    pub base__: IMAPIProp_Vtbl,
    pub GetContentsTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetHierarchyTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub OpenEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        *mut windows_core::GUID,
        u32,
        *mut u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SetSearchCriteria: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SRestriction,
        *mut SBinaryArray,
        u32,
    ) -> windows_core::HRESULT,
    pub GetSearchCriteria: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut SRestriction,
        *mut *mut SBinaryArray,
        *mut u32,
    ) -> windows_core::HRESULT,
}
pub trait IMAPIContainer_Impl: IMAPIProp_Impl {
    fn GetContentsTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn GetHierarchyTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
    ) -> windows_core::Result<()>;
    fn SetSearchCriteria(
        &self,
        lprestriction: *mut SRestriction,
        lpcontainerlist: *mut SBinaryArray,
        ulsearchflags: u32,
    ) -> windows_core::Result<()>;
    fn GetSearchCriteria(
        &self,
        ulflags: u32,
        lpprestriction: *mut *mut SRestriction,
        lppcontainerlist: *mut *mut SBinaryArray,
        lpulsearchstate: *mut u32,
    ) -> windows_core::Result<()>;
}
impl IMAPIContainer_Vtbl {
    pub const fn new<Identity: IMAPIContainer_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetContentsTable<
            Identity: IMAPIContainer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIContainer_Impl::GetContentsTable(
                    this,
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn GetHierarchyTable<
            Identity: IMAPIContainer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIContainer_Impl::GetHierarchyTable(
                    this,
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn OpenEntry<Identity: IMAPIContainer_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lpulobjtype: *mut u32,
            lppunk: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIContainer_Impl::OpenEntry(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulobjtype),
                    core::mem::transmute_copy(&lppunk),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetSearchCriteria<
            Identity: IMAPIContainer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lprestriction: *mut SRestriction,
            lpcontainerlist: *mut SBinaryArray,
            ulsearchflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIContainer_Impl::SetSearchCriteria(
                    this,
                    core::mem::transmute_copy(&lprestriction),
                    core::mem::transmute_copy(&lpcontainerlist),
                    core::mem::transmute_copy(&ulsearchflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetSearchCriteria<
            Identity: IMAPIContainer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpprestriction: *mut *mut SRestriction,
            lppcontainerlist: *mut *mut SBinaryArray,
            lpulsearchstate: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIContainer_Impl::GetSearchCriteria(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpprestriction),
                    core::mem::transmute_copy(&lppcontainerlist),
                    core::mem::transmute_copy(&lpulsearchstate),
                )
                .into()
            }
        }
        Self {
            base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
            GetContentsTable: GetContentsTable::<Identity, OFFSET>,
            GetHierarchyTable: GetHierarchyTable::<Identity, OFFSET>,
            OpenEntry: OpenEntry::<Identity, OFFSET>,
            SetSearchCriteria: SetSearchCriteria::<Identity, OFFSET>,
            GetSearchCriteria: GetSearchCriteria::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIContainer as windows_core::Interface>::IID
            || iid == &<IMAPIProp as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIContainer {}
pub const IMAPIContainer_GetContentsTable: METHODS = METHODS(37i32);
pub const IMAPIContainer_GetHierarchyTable: METHODS = METHODS(38i32);
pub const IMAPIContainer_GetSearchCriteria: METHODS = METHODS(41i32);
pub const IMAPIContainer_OpenEntry: METHODS = METHODS(39i32);
pub const IMAPIContainer_SetSearchCriteria: METHODS = METHODS(40i32);
windows_core::imp::define_interface!(
    IMAPIControl,
    IMAPIControl_Vtbl,
    0x0002031b_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIControl, windows_core::IUnknown);
impl IMAPIControl {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn Activate(&self, ulflags: u32, uluiparam: usize) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Activate)(
                windows_core::Interface::as_raw(self),
                ulflags,
                uluiparam,
            )
            .ok()
        }
    }
    pub unsafe fn GetState(&self, ulflags: u32, lpulstate: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetState)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpulstate as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIControl_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub Activate:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32, usize) -> windows_core::HRESULT,
    pub GetState:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut u32) -> windows_core::HRESULT,
}
pub trait IMAPIControl_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn Activate(&self, ulflags: u32, uluiparam: usize) -> windows_core::Result<()>;
    fn GetState(&self, ulflags: u32, lpulstate: *mut u32) -> windows_core::Result<()>;
}
impl IMAPIControl_Vtbl {
    pub const fn new<Identity: IMAPIControl_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<Identity: IMAPIControl_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIControl_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn Activate<Identity: IMAPIControl_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            uluiparam: usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIControl_Impl::Activate(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&uluiparam),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetState<Identity: IMAPIControl_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpulstate: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIControl_Impl::GetState(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulstate),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            Activate: Activate::<Identity, OFFSET>,
            GetState: GetState::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIControl as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIControl {}
pub const IMAPIControl_Activate: METHODS = METHODS(120i32);
pub const IMAPIControl_GetLastError: METHODS = METHODS(119i32);
pub const IMAPIControl_GetState: METHODS = METHODS(121i32);
windows_core::imp::define_interface!(
    IMAPIFolder,
    IMAPIFolder_Vtbl,
    0x0002030c_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMAPIFolder {
    type Target = IMAPIContainer;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IMAPIFolder,
    windows_core::IUnknown,
    IMAPIProp,
    IMAPIContainer
);
impl IMAPIFolder {
    pub unsafe fn CreateMessage(
        &self,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppmessage: *mut Option<IMessage>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CreateMessage)(
                windows_core::Interface::as_raw(self),
                lpinterface as _,
                ulflags,
                core::mem::transmute(lppmessage),
            )
            .ok()
        }
    }
    pub unsafe fn CopyMessages<P4>(
        &self,
        lpmsglist: *mut SBinaryArray,
        lpinterface: *mut windows_core::GUID,
        lpdestfolder: *mut core::ffi::c_void,
        uluiparam: usize,
        lpprogress: P4,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P4: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CopyMessages)(
                windows_core::Interface::as_raw(self),
                lpmsglist as _,
                lpinterface as _,
                lpdestfolder as _,
                uluiparam,
                lpprogress.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn DeleteMessages<P2>(
        &self,
        lpmsglist: *mut SBinaryArray,
        uluiparam: usize,
        lpprogress: P2,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteMessages)(
                windows_core::Interface::as_raw(self),
                lpmsglist as _,
                uluiparam,
                lpprogress.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn CreateFolder(
        &self,
        ulfoldertype: u32,
        lpszfoldername: *mut i8,
        lpszfoldercomment: *mut i8,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppfolder: *mut Option<IMAPIFolder>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CreateFolder)(
                windows_core::Interface::as_raw(self),
                ulfoldertype,
                lpszfoldername as _,
                lpszfoldercomment as _,
                lpinterface as _,
                ulflags,
                core::mem::transmute(lppfolder),
            )
            .ok()
        }
    }
    pub unsafe fn CopyFolder<P6>(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        lpdestfolder: *mut core::ffi::c_void,
        lpsznewfoldername: *mut i8,
        uluiparam: usize,
        lpprogress: P6,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P6: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CopyFolder)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                lpinterface as _,
                lpdestfolder as _,
                lpsznewfoldername as _,
                uluiparam,
                lpprogress.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn DeleteFolder<P3>(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        uluiparam: usize,
        lpprogress: P3,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteFolder)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                uluiparam,
                lpprogress.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn SetReadFlags<P2>(
        &self,
        lpmsglist: *mut SBinaryArray,
        uluiparam: usize,
        lpprogress: P2,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SetReadFlags)(
                windows_core::Interface::as_raw(self),
                lpmsglist as _,
                uluiparam,
                lpprogress.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetMessageStatus(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulflags: u32,
        lpulmessagestatus: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetMessageStatus)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                ulflags,
                lpulmessagestatus as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetMessageStatus(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulnewstatus: u32,
        ulnewstatusmask: u32,
        lpuloldstatus: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetMessageStatus)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                ulnewstatus,
                ulnewstatusmask,
                lpuloldstatus as _,
            )
            .ok()
        }
    }
    pub unsafe fn SaveContentsSort(
        &self,
        lpsortcriteria: *mut SSortOrderSet,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SaveContentsSort)(
                windows_core::Interface::as_raw(self),
                lpsortcriteria as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn EmptyFolder<P1>(
        &self,
        uluiparam: usize,
        lpprogress: P1,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).EmptyFolder)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                lpprogress.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIFolder_Vtbl {
    pub base__: IMAPIContainer_Vtbl,
    pub CreateMessage: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CopyMessages: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SBinaryArray,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        usize,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub DeleteMessages: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SBinaryArray,
        usize,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub CreateFolder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut i8,
        *mut i8,
        *mut windows_core::GUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CopyFolder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        *mut i8,
        usize,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub DeleteFolder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        usize,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub SetReadFlags: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SBinaryArray,
        usize,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub GetMessageStatus: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub SetMessageStatus: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        u32,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub SaveContentsSort: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SSortOrderSet,
        u32,
    ) -> windows_core::HRESULT,
    pub EmptyFolder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
}
pub trait IMAPIFolder_Impl: IMAPIContainer_Impl {
    fn CreateMessage(
        &self,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppmessage: windows_core::OutRef<'_, IMessage>,
    ) -> windows_core::Result<()>;
    fn CopyMessages(
        &self,
        lpmsglist: *mut SBinaryArray,
        lpinterface: *mut windows_core::GUID,
        lpdestfolder: *mut core::ffi::c_void,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn DeleteMessages(
        &self,
        lpmsglist: *mut SBinaryArray,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn CreateFolder(
        &self,
        ulfoldertype: u32,
        lpszfoldername: *mut i8,
        lpszfoldercomment: *mut i8,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppfolder: windows_core::OutRef<'_, IMAPIFolder>,
    ) -> windows_core::Result<()>;
    fn CopyFolder(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        lpdestfolder: *mut core::ffi::c_void,
        lpsznewfoldername: *mut i8,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn DeleteFolder(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn SetReadFlags(
        &self,
        lpmsglist: *mut SBinaryArray,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn GetMessageStatus(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulflags: u32,
        lpulmessagestatus: *mut u32,
    ) -> windows_core::Result<()>;
    fn SetMessageStatus(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulnewstatus: u32,
        ulnewstatusmask: u32,
        lpuloldstatus: *mut u32,
    ) -> windows_core::Result<()>;
    fn SaveContentsSort(
        &self,
        lpsortcriteria: *mut SSortOrderSet,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn EmptyFolder(
        &self,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
}
impl IMAPIFolder_Vtbl {
    pub const fn new<Identity: IMAPIFolder_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn CreateMessage<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lppmessage: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFolder_Impl::CreateMessage(
                    this,
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmessage),
                )
                .into()
            }
        }
        unsafe extern "system" fn CopyMessages<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpmsglist: *mut SBinaryArray,
            lpinterface: *mut windows_core::GUID,
            lpdestfolder: *mut core::ffi::c_void,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFolder_Impl::CopyMessages(
                    this,
                    core::mem::transmute_copy(&lpmsglist),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&lpdestfolder),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteMessages<
            Identity: IMAPIFolder_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpmsglist: *mut SBinaryArray,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFolder_Impl::DeleteMessages(
                    this,
                    core::mem::transmute_copy(&lpmsglist),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn CreateFolder<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulfoldertype: u32,
            lpszfoldername: *mut i8,
            lpszfoldercomment: *mut i8,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lppfolder: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFolder_Impl::CreateFolder(
                    this,
                    core::mem::transmute_copy(&ulfoldertype),
                    core::mem::transmute_copy(&lpszfoldername),
                    core::mem::transmute_copy(&lpszfoldercomment),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppfolder),
                )
                .into()
            }
        }
        unsafe extern "system" fn CopyFolder<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpinterface: *mut windows_core::GUID,
            lpdestfolder: *mut core::ffi::c_void,
            lpsznewfoldername: *mut i8,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFolder_Impl::CopyFolder(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&lpdestfolder),
                    core::mem::transmute_copy(&lpsznewfoldername),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteFolder<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFolder_Impl::DeleteFolder(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetReadFlags<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpmsglist: *mut SBinaryArray,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFolder_Impl::SetReadFlags(
                    this,
                    core::mem::transmute_copy(&lpmsglist),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMessageStatus<
            Identity: IMAPIFolder_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            ulflags: u32,
            lpulmessagestatus: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFolder_Impl::GetMessageStatus(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulmessagestatus),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetMessageStatus<
            Identity: IMAPIFolder_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            ulnewstatus: u32,
            ulnewstatusmask: u32,
            lpuloldstatus: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFolder_Impl::SetMessageStatus(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&ulnewstatus),
                    core::mem::transmute_copy(&ulnewstatusmask),
                    core::mem::transmute_copy(&lpuloldstatus),
                )
                .into()
            }
        }
        unsafe extern "system" fn SaveContentsSort<
            Identity: IMAPIFolder_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpsortcriteria: *mut SSortOrderSet,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFolder_Impl::SaveContentsSort(
                    this,
                    core::mem::transmute_copy(&lpsortcriteria),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn EmptyFolder<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFolder_Impl::EmptyFolder(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        Self {
            base__: IMAPIContainer_Vtbl::new::<Identity, OFFSET>(),
            CreateMessage: CreateMessage::<Identity, OFFSET>,
            CopyMessages: CopyMessages::<Identity, OFFSET>,
            DeleteMessages: DeleteMessages::<Identity, OFFSET>,
            CreateFolder: CreateFolder::<Identity, OFFSET>,
            CopyFolder: CopyFolder::<Identity, OFFSET>,
            DeleteFolder: DeleteFolder::<Identity, OFFSET>,
            SetReadFlags: SetReadFlags::<Identity, OFFSET>,
            GetMessageStatus: GetMessageStatus::<Identity, OFFSET>,
            SetMessageStatus: SetMessageStatus::<Identity, OFFSET>,
            SaveContentsSort: SaveContentsSort::<Identity, OFFSET>,
            EmptyFolder: EmptyFolder::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIFolder as windows_core::Interface>::IID
            || iid == &<IMAPIProp as windows_core::Interface>::IID
            || iid == &<IMAPIContainer as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIFolder {}
pub const IMAPIFolder_CopyFolder: METHODS = METHODS(54i32);
pub const IMAPIFolder_CopyMessages: METHODS = METHODS(51i32);
pub const IMAPIFolder_CreateFolder: METHODS = METHODS(53i32);
pub const IMAPIFolder_CreateMessage: METHODS = METHODS(50i32);
pub const IMAPIFolder_DeleteFolder: METHODS = METHODS(55i32);
pub const IMAPIFolder_DeleteMessages: METHODS = METHODS(52i32);
pub const IMAPIFolder_EmptyFolder: METHODS = METHODS(60i32);
pub const IMAPIFolder_GetMessageStatus: METHODS = METHODS(57i32);
pub const IMAPIFolder_SaveContentsSort: METHODS = METHODS(59i32);
pub const IMAPIFolder_SetMessageStatus: METHODS = METHODS(58i32);
pub const IMAPIFolder_SetReadFlags: METHODS = METHODS(56i32);
windows_core::imp::define_interface!(
    IMAPIForm,
    IMAPIForm_Vtbl,
    0x00020327_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIForm, windows_core::IUnknown);
impl IMAPIForm {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetViewContext<P0>(&self, pviewcontext: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMAPIViewContext>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SetViewContext)(
                windows_core::Interface::as_raw(self),
                pviewcontext.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn GetViewContext(&self) -> windows_core::Result<IMAPIViewContext> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetViewContext)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn ShutdownForm(&self, ulsaveoptions: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ShutdownForm)(
                windows_core::Interface::as_raw(self),
                ulsaveoptions,
            )
            .ok()
        }
    }
    pub unsafe fn DoVerb<P1>(
        &self,
        iverb: i32,
        lpviewcontext: P1,
        hwndparent: usize,
        lprcposrect: *mut windows::Win32::Foundation::RECT,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<IMAPIViewContext>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DoVerb)(
                windows_core::Interface::as_raw(self),
                iverb,
                lpviewcontext.param().abi(),
                hwndparent,
                lprcposrect as _,
            )
            .ok()
        }
    }
    pub unsafe fn Advise<P0>(&self, padvise: P0, pdwstatus: *mut usize) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMAPIViewAdviseSink>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Advise)(
                windows_core::Interface::as_raw(self),
                padvise.param().abi(),
                pdwstatus as _,
            )
            .ok()
        }
    }
    pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Unadvise)(
                windows_core::Interface::as_raw(self),
                ulconnection,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIForm_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub SetViewContext: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetViewContext: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ShutdownForm:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub DoVerb: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        i32,
        *mut core::ffi::c_void,
        usize,
        *mut windows::Win32::Foundation::RECT,
    ) -> windows_core::HRESULT,
    pub Advise: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut usize,
    ) -> windows_core::HRESULT,
    pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
}
pub trait IMAPIForm_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn SetViewContext(
        &self,
        pviewcontext: windows_core::Ref<'_, IMAPIViewContext>,
    ) -> windows_core::Result<()>;
    fn GetViewContext(&self) -> windows_core::Result<IMAPIViewContext>;
    fn ShutdownForm(&self, ulsaveoptions: u32) -> windows_core::Result<()>;
    fn DoVerb(
        &self,
        iverb: i32,
        lpviewcontext: windows_core::Ref<'_, IMAPIViewContext>,
        hwndparent: usize,
        lprcposrect: *mut windows::Win32::Foundation::RECT,
    ) -> windows_core::Result<()>;
    fn Advise(
        &self,
        padvise: windows_core::Ref<'_, IMAPIViewAdviseSink>,
        pdwstatus: *mut usize,
    ) -> windows_core::Result<()>;
    fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
}
impl IMAPIForm_Vtbl {
    pub const fn new<Identity: IMAPIForm_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<Identity: IMAPIForm_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIForm_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetViewContext<Identity: IMAPIForm_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pviewcontext: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIForm_Impl::SetViewContext(this, core::mem::transmute_copy(&pviewcontext))
                    .into()
            }
        }
        unsafe extern "system" fn GetViewContext<Identity: IMAPIForm_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ppviewcontext: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIForm_Impl::GetViewContext(this) {
                    Ok(ok__) => {
                        ppviewcontext.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn ShutdownForm<Identity: IMAPIForm_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulsaveoptions: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIForm_Impl::ShutdownForm(this, core::mem::transmute_copy(&ulsaveoptions)).into()
            }
        }
        unsafe extern "system" fn DoVerb<Identity: IMAPIForm_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            iverb: i32,
            lpviewcontext: *mut core::ffi::c_void,
            hwndparent: usize,
            lprcposrect: *mut windows::Win32::Foundation::RECT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIForm_Impl::DoVerb(
                    this,
                    core::mem::transmute_copy(&iverb),
                    core::mem::transmute_copy(&lpviewcontext),
                    core::mem::transmute_copy(&hwndparent),
                    core::mem::transmute_copy(&lprcposrect),
                )
                .into()
            }
        }
        unsafe extern "system" fn Advise<Identity: IMAPIForm_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            padvise: *mut core::ffi::c_void,
            pdwstatus: *mut usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIForm_Impl::Advise(
                    this,
                    core::mem::transmute_copy(&padvise),
                    core::mem::transmute_copy(&pdwstatus),
                )
                .into()
            }
        }
        unsafe extern "system" fn Unadvise<Identity: IMAPIForm_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulconnection: usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIForm_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            SetViewContext: SetViewContext::<Identity, OFFSET>,
            GetViewContext: GetViewContext::<Identity, OFFSET>,
            ShutdownForm: ShutdownForm::<Identity, OFFSET>,
            DoVerb: DoVerb::<Identity, OFFSET>,
            Advise: Advise::<Identity, OFFSET>,
            Unadvise: Unadvise::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIForm as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIForm {}
windows_core::imp::define_interface!(
    IMAPIFormAdviseSink,
    IMAPIFormAdviseSink_Vtbl,
    0x0002032f_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIFormAdviseSink, windows_core::IUnknown);
impl IMAPIFormAdviseSink {
    pub unsafe fn OnChange(&self, uldir: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OnChange)(
                windows_core::Interface::as_raw(self),
                uldir,
            )
            .ok()
        }
    }
    pub unsafe fn OnActivateNext<P0>(
        &self,
        lpszmessageclass: P0,
        ulmessagestatus: u32,
        ulmessageflags: u32,
    ) -> windows_core::Result<IPersistMessage>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).OnActivateNext)(
                windows_core::Interface::as_raw(self),
                lpszmessageclass.param().abi(),
                ulmessagestatus,
                ulmessageflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
}
#[repr(C)]
pub struct IMAPIFormAdviseSink_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub OnChange: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub OnActivateNext: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        u32,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMAPIFormAdviseSink_Impl: windows_core::IUnknownImpl {
    fn OnChange(&self, uldir: u32) -> windows_core::Result<()>;
    fn OnActivateNext(
        &self,
        lpszmessageclass: &windows_core::PCSTR,
        ulmessagestatus: u32,
        ulmessageflags: u32,
    ) -> windows_core::Result<IPersistMessage>;
}
impl IMAPIFormAdviseSink_Vtbl {
    pub const fn new<Identity: IMAPIFormAdviseSink_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn OnChange<
            Identity: IMAPIFormAdviseSink_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            uldir: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormAdviseSink_Impl::OnChange(this, core::mem::transmute_copy(&uldir)).into()
            }
        }
        unsafe extern "system" fn OnActivateNext<
            Identity: IMAPIFormAdviseSink_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszmessageclass: windows_core::PCSTR,
            ulmessagestatus: u32,
            ulmessageflags: u32,
            pppersistmessage: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIFormAdviseSink_Impl::OnActivateNext(
                    this,
                    core::mem::transmute(&lpszmessageclass),
                    core::mem::transmute_copy(&ulmessagestatus),
                    core::mem::transmute_copy(&ulmessageflags),
                ) {
                    Ok(ok__) => {
                        pppersistmessage.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            OnChange: OnChange::<Identity, OFFSET>,
            OnActivateNext: OnActivateNext::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIFormAdviseSink as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIFormAdviseSink {}
windows_core::imp::define_interface!(
    IMAPIFormContainer,
    IMAPIFormContainer_Vtbl,
    0x0002032e_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIFormContainer, windows_core::IUnknown);
impl IMAPIFormContainer {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn InstallForm(
        &self,
        uluiparam: usize,
        ulflags: u32,
        szcfgpathname: *mut i8,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).InstallForm)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                szcfgpathname as _,
            )
            .ok()
        }
    }
    pub unsafe fn RemoveForm<P0>(&self, szmessageclass: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).RemoveForm)(
                windows_core::Interface::as_raw(self),
                szmessageclass.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn ResolveMessageClass<P0>(
        &self,
        szmessageclass: P0,
        ulflags: u32,
    ) -> windows_core::Result<IMAPIFormInfo>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).ResolveMessageClass)(
                windows_core::Interface::as_raw(self),
                szmessageclass.param().abi(),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn ResolveMultipleMessageClasses(
        &self,
        pmsgclassarray: *mut SMessageClassArray,
        ulflags: u32,
        ppfrminfoarray: *mut *mut SMAPIFormInfoArray,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ResolveMultipleMessageClasses)(
                windows_core::Interface::as_raw(self),
                pmsgclassarray as _,
                ulflags,
                ppfrminfoarray as _,
            )
            .ok()
        }
    }
    pub unsafe fn CalcFormPropSet(
        &self,
        ulflags: u32,
        ppresults: *mut *mut SMAPIFormPropArray,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CalcFormPropSet)(
                windows_core::Interface::as_raw(self),
                ulflags,
                ppresults as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetDisplay(
        &self,
        ulflags: u32,
        pszdisplayname: *mut *mut i8,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetDisplay)(
                windows_core::Interface::as_raw(self),
                ulflags,
                pszdisplayname as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIFormContainer_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub InstallForm: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut i8,
    ) -> windows_core::HRESULT,
    pub RemoveForm: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
    ) -> windows_core::HRESULT,
    pub ResolveMessageClass: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ResolveMultipleMessageClasses: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SMessageClassArray,
        u32,
        *mut *mut SMAPIFormInfoArray,
    ) -> windows_core::HRESULT,
    pub CalcFormPropSet: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut SMAPIFormPropArray,
    ) -> windows_core::HRESULT,
    pub GetDisplay: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut i8,
    ) -> windows_core::HRESULT,
}
pub trait IMAPIFormContainer_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn InstallForm(
        &self,
        uluiparam: usize,
        ulflags: u32,
        szcfgpathname: *mut i8,
    ) -> windows_core::Result<()>;
    fn RemoveForm(&self, szmessageclass: &windows_core::PCSTR) -> windows_core::Result<()>;
    fn ResolveMessageClass(
        &self,
        szmessageclass: &windows_core::PCSTR,
        ulflags: u32,
    ) -> windows_core::Result<IMAPIFormInfo>;
    fn ResolveMultipleMessageClasses(
        &self,
        pmsgclassarray: *mut SMessageClassArray,
        ulflags: u32,
        ppfrminfoarray: *mut *mut SMAPIFormInfoArray,
    ) -> windows_core::Result<()>;
    fn CalcFormPropSet(
        &self,
        ulflags: u32,
        ppresults: *mut *mut SMAPIFormPropArray,
    ) -> windows_core::Result<()>;
    fn GetDisplay(&self, ulflags: u32, pszdisplayname: *mut *mut i8) -> windows_core::Result<()>;
}
impl IMAPIFormContainer_Vtbl {
    pub const fn new<Identity: IMAPIFormContainer_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IMAPIFormContainer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormContainer_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn InstallForm<
            Identity: IMAPIFormContainer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            szcfgpathname: *mut i8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormContainer_Impl::InstallForm(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&szcfgpathname),
                )
                .into()
            }
        }
        unsafe extern "system" fn RemoveForm<
            Identity: IMAPIFormContainer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            szmessageclass: windows_core::PCSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormContainer_Impl::RemoveForm(this, core::mem::transmute(&szmessageclass))
                    .into()
            }
        }
        unsafe extern "system" fn ResolveMessageClass<
            Identity: IMAPIFormContainer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            szmessageclass: windows_core::PCSTR,
            ulflags: u32,
            pforminfo: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIFormContainer_Impl::ResolveMessageClass(
                    this,
                    core::mem::transmute(&szmessageclass),
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        pforminfo.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn ResolveMultipleMessageClasses<
            Identity: IMAPIFormContainer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pmsgclassarray: *mut SMessageClassArray,
            ulflags: u32,
            ppfrminfoarray: *mut *mut SMAPIFormInfoArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormContainer_Impl::ResolveMultipleMessageClasses(
                    this,
                    core::mem::transmute_copy(&pmsgclassarray),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&ppfrminfoarray),
                )
                .into()
            }
        }
        unsafe extern "system" fn CalcFormPropSet<
            Identity: IMAPIFormContainer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            ppresults: *mut *mut SMAPIFormPropArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormContainer_Impl::CalcFormPropSet(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&ppresults),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetDisplay<
            Identity: IMAPIFormContainer_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            pszdisplayname: *mut *mut i8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormContainer_Impl::GetDisplay(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&pszdisplayname),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            InstallForm: InstallForm::<Identity, OFFSET>,
            RemoveForm: RemoveForm::<Identity, OFFSET>,
            ResolveMessageClass: ResolveMessageClass::<Identity, OFFSET>,
            ResolveMultipleMessageClasses: ResolveMultipleMessageClasses::<Identity, OFFSET>,
            CalcFormPropSet: CalcFormPropSet::<Identity, OFFSET>,
            GetDisplay: GetDisplay::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIFormContainer as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIFormContainer {}
windows_core::imp::define_interface!(
    IMAPIFormFactory,
    IMAPIFormFactory_Vtbl,
    0x00020350_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIFormFactory, windows_core::IUnknown);
impl IMAPIFormFactory {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn CreateClassFactory(
        &self,
        clsidform: *const windows_core::GUID,
        ulflags: u32,
    ) -> windows_core::Result<windows::Win32::System::Com::IClassFactory> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).CreateClassFactory)(
                windows_core::Interface::as_raw(self),
                clsidform,
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn LockServer(&self, ulflags: u32, flockserver: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).LockServer)(
                windows_core::Interface::as_raw(self),
                ulflags,
                flockserver,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIFormFactory_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub CreateClassFactory: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *const windows_core::GUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub LockServer:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32) -> windows_core::HRESULT,
}
pub trait IMAPIFormFactory_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn CreateClassFactory(
        &self,
        clsidform: *const windows_core::GUID,
        ulflags: u32,
    ) -> windows_core::Result<windows::Win32::System::Com::IClassFactory>;
    fn LockServer(&self, ulflags: u32, flockserver: u32) -> windows_core::Result<()>;
}
impl IMAPIFormFactory_Vtbl {
    pub const fn new<Identity: IMAPIFormFactory_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IMAPIFormFactory_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormFactory_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn CreateClassFactory<
            Identity: IMAPIFormFactory_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            clsidform: *const windows_core::GUID,
            ulflags: u32,
            lppclassfactory: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIFormFactory_Impl::CreateClassFactory(
                    this,
                    core::mem::transmute_copy(&clsidform),
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        lppclassfactory.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn LockServer<
            Identity: IMAPIFormFactory_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            flockserver: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormFactory_Impl::LockServer(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&flockserver),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            CreateClassFactory: CreateClassFactory::<Identity, OFFSET>,
            LockServer: LockServer::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIFormFactory as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIFormFactory {}
windows_core::imp::define_interface!(
    IMAPIFormInfo,
    IMAPIFormInfo_Vtbl,
    0x00020324_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMAPIFormInfo {
    type Target = IMAPIProp;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(IMAPIFormInfo, windows_core::IUnknown, IMAPIProp);
impl IMAPIFormInfo {
    pub unsafe fn CalcFormPropSet(
        &self,
        ulflags: u32,
        ppformproparray: *mut *mut SMAPIFormPropArray,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CalcFormPropSet)(
                windows_core::Interface::as_raw(self),
                ulflags,
                ppformproparray as _,
            )
            .ok()
        }
    }
    pub unsafe fn CalcVerbSet(
        &self,
        ulflags: u32,
        ppmapiverbarray: *mut *mut SMAPIVerbArray,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CalcVerbSet)(
                windows_core::Interface::as_raw(self),
                ulflags,
                ppmapiverbarray as _,
            )
            .ok()
        }
    }
    pub unsafe fn MakeIconFromBinary(
        &self,
        npropid: u32,
        phicon: *mut windows::Win32::UI::WindowsAndMessaging::HICON,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).MakeIconFromBinary)(
                windows_core::Interface::as_raw(self),
                npropid,
                phicon as _,
            )
            .ok()
        }
    }
    pub unsafe fn SaveForm(&self, szfilename: *mut i8) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SaveForm)(
                windows_core::Interface::as_raw(self),
                szfilename as _,
            )
            .ok()
        }
    }
    pub unsafe fn OpenFormContainer(&self) -> windows_core::Result<IMAPIFormContainer> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).OpenFormContainer)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
}
#[repr(C)]
pub struct IMAPIFormInfo_Vtbl {
    pub base__: IMAPIProp_Vtbl,
    pub CalcFormPropSet: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut SMAPIFormPropArray,
    ) -> windows_core::HRESULT,
    pub CalcVerbSet: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut SMAPIVerbArray,
    ) -> windows_core::HRESULT,
    pub MakeIconFromBinary: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut windows::Win32::UI::WindowsAndMessaging::HICON,
    ) -> windows_core::HRESULT,
    pub SaveForm:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut i8) -> windows_core::HRESULT,
    pub OpenFormContainer: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMAPIFormInfo_Impl: IMAPIProp_Impl {
    fn CalcFormPropSet(
        &self,
        ulflags: u32,
        ppformproparray: *mut *mut SMAPIFormPropArray,
    ) -> windows_core::Result<()>;
    fn CalcVerbSet(
        &self,
        ulflags: u32,
        ppmapiverbarray: *mut *mut SMAPIVerbArray,
    ) -> windows_core::Result<()>;
    fn MakeIconFromBinary(
        &self,
        npropid: u32,
        phicon: *mut windows::Win32::UI::WindowsAndMessaging::HICON,
    ) -> windows_core::Result<()>;
    fn SaveForm(&self, szfilename: *mut i8) -> windows_core::Result<()>;
    fn OpenFormContainer(&self) -> windows_core::Result<IMAPIFormContainer>;
}
impl IMAPIFormInfo_Vtbl {
    pub const fn new<Identity: IMAPIFormInfo_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn CalcFormPropSet<
            Identity: IMAPIFormInfo_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            ppformproparray: *mut *mut SMAPIFormPropArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormInfo_Impl::CalcFormPropSet(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&ppformproparray),
                )
                .into()
            }
        }
        unsafe extern "system" fn CalcVerbSet<Identity: IMAPIFormInfo_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            ppmapiverbarray: *mut *mut SMAPIVerbArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormInfo_Impl::CalcVerbSet(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&ppmapiverbarray),
                )
                .into()
            }
        }
        unsafe extern "system" fn MakeIconFromBinary<
            Identity: IMAPIFormInfo_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            npropid: u32,
            phicon: *mut windows::Win32::UI::WindowsAndMessaging::HICON,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormInfo_Impl::MakeIconFromBinary(
                    this,
                    core::mem::transmute_copy(&npropid),
                    core::mem::transmute_copy(&phicon),
                )
                .into()
            }
        }
        unsafe extern "system" fn SaveForm<Identity: IMAPIFormInfo_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            szfilename: *mut i8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormInfo_Impl::SaveForm(this, core::mem::transmute_copy(&szfilename)).into()
            }
        }
        unsafe extern "system" fn OpenFormContainer<
            Identity: IMAPIFormInfo_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ppformcontainer: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIFormInfo_Impl::OpenFormContainer(this) {
                    Ok(ok__) => {
                        ppformcontainer.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
            CalcFormPropSet: CalcFormPropSet::<Identity, OFFSET>,
            CalcVerbSet: CalcVerbSet::<Identity, OFFSET>,
            MakeIconFromBinary: MakeIconFromBinary::<Identity, OFFSET>,
            SaveForm: SaveForm::<Identity, OFFSET>,
            OpenFormContainer: OpenFormContainer::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIFormInfo as windows_core::Interface>::IID
            || iid == &<IMAPIProp as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIFormInfo {}
windows_core::imp::define_interface!(
    IMAPIFormMgr,
    IMAPIFormMgr_Vtbl,
    0x00020322_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIFormMgr, windows_core::IUnknown);
impl IMAPIFormMgr {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn LoadForm<P2, P5, P6, P7, P8>(
        &self,
        uluiparam: usize,
        ulflags: u32,
        lpszmessageclass: P2,
        ulmessagestatus: u32,
        ulmessageflags: u32,
        pfolderfocus: P5,
        pmessagesite: P6,
        pmsg: P7,
        pviewcontext: P8,
        riid: *const windows_core::GUID,
        ppvobj: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<windows_core::PCSTR>,
        P5: windows_core::Param<IMAPIFolder>,
        P6: windows_core::Param<IMAPIMessageSite>,
        P7: windows_core::Param<IMessage>,
        P8: windows_core::Param<IMAPIViewContext>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).LoadForm)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                lpszmessageclass.param().abi(),
                ulmessagestatus,
                ulmessageflags,
                pfolderfocus.param().abi(),
                pmessagesite.param().abi(),
                pmsg.param().abi(),
                pviewcontext.param().abi(),
                riid,
                ppvobj as _,
            )
            .ok()
        }
    }
    pub unsafe fn ResolveMessageClass<P0, P2>(
        &self,
        szmsgclass: P0,
        ulflags: u32,
        pfolderfocus: P2,
    ) -> windows_core::Result<IMAPIFormInfo>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
        P2: windows_core::Param<IMAPIFolder>,
    {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).ResolveMessageClass)(
                windows_core::Interface::as_raw(self),
                szmsgclass.param().abi(),
                ulflags,
                pfolderfocus.param().abi(),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn ResolveMultipleMessageClasses<P2>(
        &self,
        pmsgclasses: *mut SMessageClassArray,
        ulflags: u32,
        pfolderfocus: P2,
        pfrminfoarray: *mut *mut SMAPIFormInfoArray,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<IMAPIFolder>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).ResolveMultipleMessageClasses)(
                windows_core::Interface::as_raw(self),
                pmsgclasses as _,
                ulflags,
                pfolderfocus.param().abi(),
                pfrminfoarray as _,
            )
            .ok()
        }
    }
    pub unsafe fn CalcFormPropSet(
        &self,
        pfrminfoarray: *mut SMAPIFormInfoArray,
        ulflags: u32,
        ppresults: *mut *mut SMAPIFormPropArray,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CalcFormPropSet)(
                windows_core::Interface::as_raw(self),
                core::mem::transmute(pfrminfoarray),
                ulflags,
                ppresults as _,
            )
            .ok()
        }
    }
    pub unsafe fn CreateForm<P2>(
        &self,
        uluiparam: usize,
        ulflags: u32,
        pfrminfotoactivate: P2,
        refiidtoask: *const windows_core::GUID,
        ppvobj: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<IMAPIFormInfo>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CreateForm)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                pfrminfotoactivate.param().abi(),
                refiidtoask,
                ppvobj as _,
            )
            .ok()
        }
    }
    pub unsafe fn SelectForm<P3>(
        &self,
        uluiparam: usize,
        ulflags: u32,
        psztitle: *mut i8,
        pfld: P3,
        ppfrminforeturned: *mut Option<IMAPIFormInfo>,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<IMAPIFolder>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SelectForm)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                psztitle as _,
                pfld.param().abi(),
                core::mem::transmute(ppfrminforeturned),
            )
            .ok()
        }
    }
    pub unsafe fn SelectMultipleForms<P3>(
        &self,
        uluiparam: usize,
        ulflags: u32,
        psztitle: *mut i8,
        pfld: P3,
        pfrminfoarray: *mut SMAPIFormInfoArray,
        ppfrminfoarray: *mut *mut SMAPIFormInfoArray,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<IMAPIFolder>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SelectMultipleForms)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                psztitle as _,
                pfld.param().abi(),
                core::mem::transmute(pfrminfoarray),
                ppfrminfoarray as _,
            )
            .ok()
        }
    }
    pub unsafe fn SelectFormContainer(
        &self,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<IMAPIFormContainer> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).SelectFormContainer)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn OpenFormContainer<P1>(
        &self,
        hfrmreg: u32,
        lpunk: P1,
    ) -> windows_core::Result<IMAPIFormContainer>
    where
        P1: windows_core::Param<windows_core::IUnknown>,
    {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).OpenFormContainer)(
                windows_core::Interface::as_raw(self),
                hfrmreg,
                lpunk.param().abi(),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn PrepareForm<P2>(
        &self,
        uluiparam: usize,
        ulflags: u32,
        pfrminfo: P2,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<IMAPIFormInfo>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).PrepareForm)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                pfrminfo.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn IsInConflict<P2, P3>(
        &self,
        ulmessageflags: u32,
        ulmessagestatus: u32,
        szmessageclass: P2,
        pfolderfocus: P3,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<windows_core::PCSTR>,
        P3: windows_core::Param<IMAPIFolder>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).IsInConflict)(
                windows_core::Interface::as_raw(self),
                ulmessageflags,
                ulmessagestatus,
                szmessageclass.param().abi(),
                pfolderfocus.param().abi(),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIFormMgr_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub LoadForm: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        windows_core::PCSTR,
        u32,
        u32,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *const windows_core::GUID,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ResolveMessageClass: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        u32,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ResolveMultipleMessageClasses: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SMessageClassArray,
        u32,
        *mut core::ffi::c_void,
        *mut *mut SMAPIFormInfoArray,
    ) -> windows_core::HRESULT,
    pub CalcFormPropSet: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SMAPIFormInfoArray,
        u32,
        *mut *mut SMAPIFormPropArray,
    ) -> windows_core::HRESULT,
    pub CreateForm: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut core::ffi::c_void,
        *const windows_core::GUID,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SelectForm: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut i8,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SelectMultipleForms: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut i8,
        *mut core::ffi::c_void,
        *mut SMAPIFormInfoArray,
        *mut *mut SMAPIFormInfoArray,
    ) -> windows_core::HRESULT,
    pub SelectFormContainer: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub OpenFormContainer: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub PrepareForm: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub IsInConflict: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        windows_core::PCSTR,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMAPIFormMgr_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn LoadForm(
        &self,
        uluiparam: usize,
        ulflags: u32,
        lpszmessageclass: &windows_core::PCSTR,
        ulmessagestatus: u32,
        ulmessageflags: u32,
        pfolderfocus: windows_core::Ref<'_, IMAPIFolder>,
        pmessagesite: windows_core::Ref<'_, IMAPIMessageSite>,
        pmsg: windows_core::Ref<'_, IMessage>,
        pviewcontext: windows_core::Ref<'_, IMAPIViewContext>,
        riid: *const windows_core::GUID,
        ppvobj: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()>;
    fn ResolveMessageClass(
        &self,
        szmsgclass: &windows_core::PCSTR,
        ulflags: u32,
        pfolderfocus: windows_core::Ref<'_, IMAPIFolder>,
    ) -> windows_core::Result<IMAPIFormInfo>;
    fn ResolveMultipleMessageClasses(
        &self,
        pmsgclasses: *mut SMessageClassArray,
        ulflags: u32,
        pfolderfocus: windows_core::Ref<'_, IMAPIFolder>,
        pfrminfoarray: *mut *mut SMAPIFormInfoArray,
    ) -> windows_core::Result<()>;
    fn CalcFormPropSet(
        &self,
        pfrminfoarray: *mut SMAPIFormInfoArray,
        ulflags: u32,
        ppresults: *mut *mut SMAPIFormPropArray,
    ) -> windows_core::Result<()>;
    fn CreateForm(
        &self,
        uluiparam: usize,
        ulflags: u32,
        pfrminfotoactivate: windows_core::Ref<'_, IMAPIFormInfo>,
        refiidtoask: *const windows_core::GUID,
        ppvobj: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()>;
    fn SelectForm(
        &self,
        uluiparam: usize,
        ulflags: u32,
        psztitle: *mut i8,
        pfld: windows_core::Ref<'_, IMAPIFolder>,
        ppfrminforeturned: windows_core::OutRef<'_, IMAPIFormInfo>,
    ) -> windows_core::Result<()>;
    fn SelectMultipleForms(
        &self,
        uluiparam: usize,
        ulflags: u32,
        psztitle: *mut i8,
        pfld: windows_core::Ref<'_, IMAPIFolder>,
        pfrminfoarray: *mut SMAPIFormInfoArray,
        ppfrminfoarray: *mut *mut SMAPIFormInfoArray,
    ) -> windows_core::Result<()>;
    fn SelectFormContainer(
        &self,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<IMAPIFormContainer>;
    fn OpenFormContainer(
        &self,
        hfrmreg: u32,
        lpunk: windows_core::Ref<'_, windows_core::IUnknown>,
    ) -> windows_core::Result<IMAPIFormContainer>;
    fn PrepareForm(
        &self,
        uluiparam: usize,
        ulflags: u32,
        pfrminfo: windows_core::Ref<'_, IMAPIFormInfo>,
    ) -> windows_core::Result<()>;
    fn IsInConflict(
        &self,
        ulmessageflags: u32,
        ulmessagestatus: u32,
        szmessageclass: &windows_core::PCSTR,
        pfolderfocus: windows_core::Ref<'_, IMAPIFolder>,
    ) -> windows_core::Result<()>;
}
impl IMAPIFormMgr_Vtbl {
    pub const fn new<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormMgr_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn LoadForm<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            lpszmessageclass: windows_core::PCSTR,
            ulmessagestatus: u32,
            ulmessageflags: u32,
            pfolderfocus: *mut core::ffi::c_void,
            pmessagesite: *mut core::ffi::c_void,
            pmsg: *mut core::ffi::c_void,
            pviewcontext: *mut core::ffi::c_void,
            riid: *const windows_core::GUID,
            ppvobj: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormMgr_Impl::LoadForm(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute(&lpszmessageclass),
                    core::mem::transmute_copy(&ulmessagestatus),
                    core::mem::transmute_copy(&ulmessageflags),
                    core::mem::transmute_copy(&pfolderfocus),
                    core::mem::transmute_copy(&pmessagesite),
                    core::mem::transmute_copy(&pmsg),
                    core::mem::transmute_copy(&pviewcontext),
                    core::mem::transmute_copy(&riid),
                    core::mem::transmute_copy(&ppvobj),
                )
                .into()
            }
        }
        unsafe extern "system" fn ResolveMessageClass<
            Identity: IMAPIFormMgr_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            szmsgclass: windows_core::PCSTR,
            ulflags: u32,
            pfolderfocus: *mut core::ffi::c_void,
            ppresult: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIFormMgr_Impl::ResolveMessageClass(
                    this,
                    core::mem::transmute(&szmsgclass),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&pfolderfocus),
                ) {
                    Ok(ok__) => {
                        ppresult.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn ResolveMultipleMessageClasses<
            Identity: IMAPIFormMgr_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pmsgclasses: *mut SMessageClassArray,
            ulflags: u32,
            pfolderfocus: *mut core::ffi::c_void,
            pfrminfoarray: *mut *mut SMAPIFormInfoArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormMgr_Impl::ResolveMultipleMessageClasses(
                    this,
                    core::mem::transmute_copy(&pmsgclasses),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&pfolderfocus),
                    core::mem::transmute_copy(&pfrminfoarray),
                )
                .into()
            }
        }
        unsafe extern "system" fn CalcFormPropSet<
            Identity: IMAPIFormMgr_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pfrminfoarray: *mut SMAPIFormInfoArray,
            ulflags: u32,
            ppresults: *mut *mut SMAPIFormPropArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormMgr_Impl::CalcFormPropSet(
                    this,
                    core::mem::transmute_copy(&pfrminfoarray),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&ppresults),
                )
                .into()
            }
        }
        unsafe extern "system" fn CreateForm<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            pfrminfotoactivate: *mut core::ffi::c_void,
            refiidtoask: *const windows_core::GUID,
            ppvobj: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormMgr_Impl::CreateForm(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&pfrminfotoactivate),
                    core::mem::transmute_copy(&refiidtoask),
                    core::mem::transmute_copy(&ppvobj),
                )
                .into()
            }
        }
        unsafe extern "system" fn SelectForm<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            psztitle: *mut i8,
            pfld: *mut core::ffi::c_void,
            ppfrminforeturned: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormMgr_Impl::SelectForm(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&psztitle),
                    core::mem::transmute_copy(&pfld),
                    core::mem::transmute_copy(&ppfrminforeturned),
                )
                .into()
            }
        }
        unsafe extern "system" fn SelectMultipleForms<
            Identity: IMAPIFormMgr_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            psztitle: *mut i8,
            pfld: *mut core::ffi::c_void,
            pfrminfoarray: *mut SMAPIFormInfoArray,
            ppfrminfoarray: *mut *mut SMAPIFormInfoArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormMgr_Impl::SelectMultipleForms(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&psztitle),
                    core::mem::transmute_copy(&pfld),
                    core::mem::transmute_copy(&pfrminfoarray),
                    core::mem::transmute_copy(&ppfrminfoarray),
                )
                .into()
            }
        }
        unsafe extern "system" fn SelectFormContainer<
            Identity: IMAPIFormMgr_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            lppfcnt: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIFormMgr_Impl::SelectFormContainer(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        lppfcnt.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn OpenFormContainer<
            Identity: IMAPIFormMgr_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hfrmreg: u32,
            lpunk: *mut core::ffi::c_void,
            lppfcnt: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIFormMgr_Impl::OpenFormContainer(
                    this,
                    core::mem::transmute_copy(&hfrmreg),
                    core::mem::transmute_copy(&lpunk),
                ) {
                    Ok(ok__) => {
                        lppfcnt.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn PrepareForm<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            pfrminfo: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormMgr_Impl::PrepareForm(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&pfrminfo),
                )
                .into()
            }
        }
        unsafe extern "system" fn IsInConflict<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulmessageflags: u32,
            ulmessagestatus: u32,
            szmessageclass: windows_core::PCSTR,
            pfolderfocus: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIFormMgr_Impl::IsInConflict(
                    this,
                    core::mem::transmute_copy(&ulmessageflags),
                    core::mem::transmute_copy(&ulmessagestatus),
                    core::mem::transmute(&szmessageclass),
                    core::mem::transmute_copy(&pfolderfocus),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            LoadForm: LoadForm::<Identity, OFFSET>,
            ResolveMessageClass: ResolveMessageClass::<Identity, OFFSET>,
            ResolveMultipleMessageClasses: ResolveMultipleMessageClasses::<Identity, OFFSET>,
            CalcFormPropSet: CalcFormPropSet::<Identity, OFFSET>,
            CreateForm: CreateForm::<Identity, OFFSET>,
            SelectForm: SelectForm::<Identity, OFFSET>,
            SelectMultipleForms: SelectMultipleForms::<Identity, OFFSET>,
            SelectFormContainer: SelectFormContainer::<Identity, OFFSET>,
            OpenFormContainer: OpenFormContainer::<Identity, OFFSET>,
            PrepareForm: PrepareForm::<Identity, OFFSET>,
            IsInConflict: IsInConflict::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIFormMgr as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIFormMgr {}
windows_core::imp::define_interface!(
    IMAPIMessageSite,
    IMAPIMessageSite_Vtbl,
    0x00020370_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIMessageSite, windows_core::IUnknown);
impl IMAPIMessageSite {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetSession(&self) -> windows_core::Result<IMAPISession> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetSession)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn GetStore(&self) -> windows_core::Result<IMsgStore> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetStore)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn GetFolder(&self) -> windows_core::Result<IMAPIFolder> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetFolder)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn GetMessageA(&self) -> windows_core::Result<IMessage> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetMessageA)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn GetFormManager(&self) -> windows_core::Result<IMAPIFormMgr> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetFormManager)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn NewMessage<P1, P2>(
        &self,
        fcomposeinfolder: u32,
        pfolderfocus: P1,
        ppersistmessage: P2,
        ppmessage: *mut Option<IMessage>,
        ppmessagesite: *mut Option<IMAPIMessageSite>,
        ppviewcontext: *mut Option<IMAPIViewContext>,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<IMAPIFolder>,
        P2: windows_core::Param<IPersistMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).NewMessage)(
                windows_core::Interface::as_raw(self),
                fcomposeinfolder,
                pfolderfocus.param().abi(),
                ppersistmessage.param().abi(),
                core::mem::transmute(ppmessage),
                core::mem::transmute(ppmessagesite),
                core::mem::transmute(ppviewcontext),
            )
            .ok()
        }
    }
    pub unsafe fn CopyMessage<P0>(&self, pfolderdestination: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMAPIFolder>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CopyMessage)(
                windows_core::Interface::as_raw(self),
                pfolderdestination.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn MoveMessage<P0, P1>(
        &self,
        pfolderdestination: P0,
        pviewcontext: P1,
        prcposrect: *mut windows::Win32::Foundation::RECT,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMAPIFolder>,
        P1: windows_core::Param<IMAPIViewContext>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).MoveMessage)(
                windows_core::Interface::as_raw(self),
                pfolderdestination.param().abi(),
                pviewcontext.param().abi(),
                prcposrect as _,
            )
            .ok()
        }
    }
    pub unsafe fn DeleteMessage<P0>(
        &self,
        pviewcontext: P0,
        prcposrect: *mut windows::Win32::Foundation::RECT,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMAPIViewContext>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteMessage)(
                windows_core::Interface::as_raw(self),
                pviewcontext.param().abi(),
                prcposrect as _,
            )
            .ok()
        }
    }
    pub unsafe fn SaveMessage(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SaveMessage)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn SubmitMessage(&self, ulflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SubmitMessage)(
                windows_core::Interface::as_raw(self),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetSiteStatus(&self, lpulstatus: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetSiteStatus)(
                windows_core::Interface::as_raw(self),
                lpulstatus as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIMessageSite_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub GetSession: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetStore: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetFolder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetMessageA: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetFormManager: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub NewMessage: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CopyMessage: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub MoveMessage: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut windows::Win32::Foundation::RECT,
    ) -> windows_core::HRESULT,
    pub DeleteMessage: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut windows::Win32::Foundation::RECT,
    ) -> windows_core::HRESULT,
    pub SaveMessage: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub SubmitMessage:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub GetSiteStatus:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMAPIMessageSite_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn GetSession(&self) -> windows_core::Result<IMAPISession>;
    fn GetStore(&self) -> windows_core::Result<IMsgStore>;
    fn GetFolder(&self) -> windows_core::Result<IMAPIFolder>;
    fn GetMessageA(&self) -> windows_core::Result<IMessage>;
    fn GetFormManager(&self) -> windows_core::Result<IMAPIFormMgr>;
    fn NewMessage(
        &self,
        fcomposeinfolder: u32,
        pfolderfocus: windows_core::Ref<'_, IMAPIFolder>,
        ppersistmessage: windows_core::Ref<'_, IPersistMessage>,
        ppmessage: windows_core::OutRef<'_, IMessage>,
        ppmessagesite: windows_core::OutRef<'_, IMAPIMessageSite>,
        ppviewcontext: windows_core::OutRef<'_, IMAPIViewContext>,
    ) -> windows_core::Result<()>;
    fn CopyMessage(
        &self,
        pfolderdestination: windows_core::Ref<'_, IMAPIFolder>,
    ) -> windows_core::Result<()>;
    fn MoveMessage(
        &self,
        pfolderdestination: windows_core::Ref<'_, IMAPIFolder>,
        pviewcontext: windows_core::Ref<'_, IMAPIViewContext>,
        prcposrect: *mut windows::Win32::Foundation::RECT,
    ) -> windows_core::Result<()>;
    fn DeleteMessage(
        &self,
        pviewcontext: windows_core::Ref<'_, IMAPIViewContext>,
        prcposrect: *mut windows::Win32::Foundation::RECT,
    ) -> windows_core::Result<()>;
    fn SaveMessage(&self) -> windows_core::Result<()>;
    fn SubmitMessage(&self, ulflags: u32) -> windows_core::Result<()>;
    fn GetSiteStatus(&self, lpulstatus: *mut u32) -> windows_core::Result<()>;
}
impl IMAPIMessageSite_Vtbl {
    pub const fn new<Identity: IMAPIMessageSite_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IMAPIMessageSite_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIMessageSite_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetSession<
            Identity: IMAPIMessageSite_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ppsession: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIMessageSite_Impl::GetSession(this) {
                    Ok(ok__) => {
                        ppsession.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn GetStore<Identity: IMAPIMessageSite_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ppstore: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIMessageSite_Impl::GetStore(this) {
                    Ok(ok__) => {
                        ppstore.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn GetFolder<
            Identity: IMAPIMessageSite_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ppfolder: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIMessageSite_Impl::GetFolder(this) {
                    Ok(ok__) => {
                        ppfolder.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn GetMessageA<
            Identity: IMAPIMessageSite_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ppmsg: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIMessageSite_Impl::GetMessageA(this) {
                    Ok(ok__) => {
                        ppmsg.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn GetFormManager<
            Identity: IMAPIMessageSite_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ppformmgr: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPIMessageSite_Impl::GetFormManager(this) {
                    Ok(ok__) => {
                        ppformmgr.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn NewMessage<
            Identity: IMAPIMessageSite_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            fcomposeinfolder: u32,
            pfolderfocus: *mut core::ffi::c_void,
            ppersistmessage: *mut core::ffi::c_void,
            ppmessage: *mut *mut core::ffi::c_void,
            ppmessagesite: *mut *mut core::ffi::c_void,
            ppviewcontext: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIMessageSite_Impl::NewMessage(
                    this,
                    core::mem::transmute_copy(&fcomposeinfolder),
                    core::mem::transmute_copy(&pfolderfocus),
                    core::mem::transmute_copy(&ppersistmessage),
                    core::mem::transmute_copy(&ppmessage),
                    core::mem::transmute_copy(&ppmessagesite),
                    core::mem::transmute_copy(&ppviewcontext),
                )
                .into()
            }
        }
        unsafe extern "system" fn CopyMessage<
            Identity: IMAPIMessageSite_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pfolderdestination: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIMessageSite_Impl::CopyMessage(
                    this,
                    core::mem::transmute_copy(&pfolderdestination),
                )
                .into()
            }
        }
        unsafe extern "system" fn MoveMessage<
            Identity: IMAPIMessageSite_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pfolderdestination: *mut core::ffi::c_void,
            pviewcontext: *mut core::ffi::c_void,
            prcposrect: *mut windows::Win32::Foundation::RECT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIMessageSite_Impl::MoveMessage(
                    this,
                    core::mem::transmute_copy(&pfolderdestination),
                    core::mem::transmute_copy(&pviewcontext),
                    core::mem::transmute_copy(&prcposrect),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteMessage<
            Identity: IMAPIMessageSite_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pviewcontext: *mut core::ffi::c_void,
            prcposrect: *mut windows::Win32::Foundation::RECT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIMessageSite_Impl::DeleteMessage(
                    this,
                    core::mem::transmute_copy(&pviewcontext),
                    core::mem::transmute_copy(&prcposrect),
                )
                .into()
            }
        }
        unsafe extern "system" fn SaveMessage<
            Identity: IMAPIMessageSite_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIMessageSite_Impl::SaveMessage(this).into()
            }
        }
        unsafe extern "system" fn SubmitMessage<
            Identity: IMAPIMessageSite_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIMessageSite_Impl::SubmitMessage(this, core::mem::transmute_copy(&ulflags))
                    .into()
            }
        }
        unsafe extern "system" fn GetSiteStatus<
            Identity: IMAPIMessageSite_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpulstatus: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIMessageSite_Impl::GetSiteStatus(this, core::mem::transmute_copy(&lpulstatus))
                    .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            GetSession: GetSession::<Identity, OFFSET>,
            GetStore: GetStore::<Identity, OFFSET>,
            GetFolder: GetFolder::<Identity, OFFSET>,
            GetMessageA: GetMessageA::<Identity, OFFSET>,
            GetFormManager: GetFormManager::<Identity, OFFSET>,
            NewMessage: NewMessage::<Identity, OFFSET>,
            CopyMessage: CopyMessage::<Identity, OFFSET>,
            MoveMessage: MoveMessage::<Identity, OFFSET>,
            DeleteMessage: DeleteMessage::<Identity, OFFSET>,
            SaveMessage: SaveMessage::<Identity, OFFSET>,
            SubmitMessage: SubmitMessage::<Identity, OFFSET>,
            GetSiteStatus: GetSiteStatus::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIMessageSite as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIMessageSite {}
windows_core::imp::define_interface!(
    IMAPIProgress,
    IMAPIProgress_Vtbl,
    0x0002031f_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIProgress, windows_core::IUnknown);
impl IMAPIProgress {
    pub unsafe fn Progress(
        &self,
        ulvalue: u32,
        ulcount: u32,
        ultotal: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Progress)(
                windows_core::Interface::as_raw(self),
                ulvalue,
                ulcount,
                ultotal,
            )
            .ok()
        }
    }
    pub unsafe fn GetFlags(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetFlags)(
                windows_core::Interface::as_raw(self),
                lpulflags as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMax(&self, lpulmax: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetMax)(
                windows_core::Interface::as_raw(self),
                lpulmax as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMin(&self, lpulmin: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetMin)(
                windows_core::Interface::as_raw(self),
                lpulmin as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetLimits(
        &self,
        lpulmin: *mut u32,
        lpulmax: *mut u32,
        lpulflags: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetLimits)(
                windows_core::Interface::as_raw(self),
                lpulmin as _,
                lpulmax as _,
                lpulflags as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIProgress_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Progress:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32, u32) -> windows_core::HRESULT,
    pub GetFlags:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub GetMax:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub GetMin:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub SetLimits: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut u32,
        *mut u32,
        *mut u32,
    ) -> windows_core::HRESULT,
}
pub trait IMAPIProgress_Impl: windows_core::IUnknownImpl {
    fn Progress(&self, ulvalue: u32, ulcount: u32, ultotal: u32) -> windows_core::Result<()>;
    fn GetFlags(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
    fn GetMax(&self, lpulmax: *mut u32) -> windows_core::Result<()>;
    fn GetMin(&self, lpulmin: *mut u32) -> windows_core::Result<()>;
    fn SetLimits(
        &self,
        lpulmin: *mut u32,
        lpulmax: *mut u32,
        lpulflags: *mut u32,
    ) -> windows_core::Result<()>;
}
impl IMAPIProgress_Vtbl {
    pub const fn new<Identity: IMAPIProgress_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Progress<Identity: IMAPIProgress_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulvalue: u32,
            ulcount: u32,
            ultotal: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProgress_Impl::Progress(
                    this,
                    core::mem::transmute_copy(&ulvalue),
                    core::mem::transmute_copy(&ulcount),
                    core::mem::transmute_copy(&ultotal),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetFlags<Identity: IMAPIProgress_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulflags: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProgress_Impl::GetFlags(this, core::mem::transmute_copy(&lpulflags)).into()
            }
        }
        unsafe extern "system" fn GetMax<Identity: IMAPIProgress_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulmax: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProgress_Impl::GetMax(this, core::mem::transmute_copy(&lpulmax)).into()
            }
        }
        unsafe extern "system" fn GetMin<Identity: IMAPIProgress_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulmin: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProgress_Impl::GetMin(this, core::mem::transmute_copy(&lpulmin)).into()
            }
        }
        unsafe extern "system" fn SetLimits<Identity: IMAPIProgress_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulmin: *mut u32,
            lpulmax: *mut u32,
            lpulflags: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProgress_Impl::SetLimits(
                    this,
                    core::mem::transmute_copy(&lpulmin),
                    core::mem::transmute_copy(&lpulmax),
                    core::mem::transmute_copy(&lpulflags),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Progress: Progress::<Identity, OFFSET>,
            GetFlags: GetFlags::<Identity, OFFSET>,
            GetMax: GetMax::<Identity, OFFSET>,
            GetMin: GetMin::<Identity, OFFSET>,
            SetLimits: SetLimits::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIProgress as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIProgress {}
windows_core::imp::define_interface!(
    IMAPIProp,
    IMAPIProp_Vtbl,
    0x00020303_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIProp, windows_core::IUnknown);
impl IMAPIProp {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn SaveChanges(&self, ulflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SaveChanges)(
                windows_core::Interface::as_raw(self),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetProps(
        &self,
        lpproptagarray: *mut SPropTagArray,
        ulflags: u32,
        lpcvalues: *mut u32,
        lppproparray: *mut *mut SPropValue,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetProps)(
                windows_core::Interface::as_raw(self),
                lpproptagarray as _,
                ulflags,
                lpcvalues as _,
                lppproparray as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetPropList(
        &self,
        ulflags: u32,
        lppproptagarray: *mut *mut SPropTagArray,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetPropList)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lppproptagarray as _,
            )
            .ok()
        }
    }
    pub unsafe fn OpenProperty(
        &self,
        ulproptag: u32,
        lpiid: *mut windows_core::GUID,
        ulinterfaceoptions: u32,
        ulflags: u32,
        lppunk: *mut Option<windows_core::IUnknown>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenProperty)(
                windows_core::Interface::as_raw(self),
                ulproptag,
                lpiid as _,
                ulinterfaceoptions,
                ulflags,
                core::mem::transmute(lppunk),
            )
            .ok()
        }
    }
    pub unsafe fn SetProps(
        &self,
        cvalues: u32,
        lpproparray: *mut SPropValue,
        lppproblems: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetProps)(
                windows_core::Interface::as_raw(self),
                cvalues,
                lpproparray as _,
                lppproblems as _,
            )
            .ok()
        }
    }
    pub unsafe fn DeleteProps(
        &self,
        lpproptagarray: *mut SPropTagArray,
        lppproblems: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteProps)(
                windows_core::Interface::as_raw(self),
                lpproptagarray as _,
                lppproblems as _,
            )
            .ok()
        }
    }
    pub unsafe fn CopyTo<P4>(
        &self,
        ciidexclude: u32,
        rgiidexclude: *mut windows_core::GUID,
        lpexcludeprops: *mut SPropTagArray,
        uluiparam: usize,
        lpprogress: P4,
        lpinterface: *mut windows_core::GUID,
        lpdestobj: *mut core::ffi::c_void,
        ulflags: u32,
        lppproblems: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()>
    where
        P4: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CopyTo)(
                windows_core::Interface::as_raw(self),
                ciidexclude,
                rgiidexclude as _,
                lpexcludeprops as _,
                uluiparam,
                lpprogress.param().abi(),
                lpinterface as _,
                lpdestobj as _,
                ulflags,
                lppproblems as _,
            )
            .ok()
        }
    }
    pub unsafe fn CopyProps<P2>(
        &self,
        lpincludeprops: *mut SPropTagArray,
        uluiparam: usize,
        lpprogress: P2,
        lpinterface: *mut windows_core::GUID,
        lpdestobj: *mut core::ffi::c_void,
        ulflags: u32,
        lppproblems: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CopyProps)(
                windows_core::Interface::as_raw(self),
                lpincludeprops as _,
                uluiparam,
                lpprogress.param().abi(),
                lpinterface as _,
                lpdestobj as _,
                ulflags,
                lppproblems as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetNamesFromIDs(
        &self,
        lppproptags: *mut *mut SPropTagArray,
        lppropsetguid: *mut windows_core::GUID,
        ulflags: u32,
        lpcpropnames: *mut u32,
        lppppropnames: *mut *mut *mut MAPINAMEID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetNamesFromIDs)(
                windows_core::Interface::as_raw(self),
                lppproptags as _,
                lppropsetguid as _,
                ulflags,
                lpcpropnames as _,
                lppppropnames as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetIDsFromNames(
        &self,
        cpropnames: u32,
        lpppropnames: *mut *mut MAPINAMEID,
        ulflags: u32,
        lppproptags: *mut *mut SPropTagArray,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetIDsFromNames)(
                windows_core::Interface::as_raw(self),
                cpropnames,
                lpppropnames as _,
                ulflags,
                lppproptags as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIProp_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub SaveChanges:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub GetProps: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SPropTagArray,
        u32,
        *mut u32,
        *mut *mut SPropValue,
    ) -> windows_core::HRESULT,
    pub GetPropList: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut SPropTagArray,
    ) -> windows_core::HRESULT,
    pub OpenProperty: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut windows_core::GUID,
        u32,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SetProps: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut SPropValue,
        *mut *mut SPropProblemArray,
    ) -> windows_core::HRESULT,
    pub DeleteProps: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SPropTagArray,
        *mut *mut SPropProblemArray,
    ) -> windows_core::HRESULT,
    pub CopyTo: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut windows_core::GUID,
        *mut SPropTagArray,
        usize,
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        u32,
        *mut *mut SPropProblemArray,
    ) -> windows_core::HRESULT,
    pub CopyProps: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SPropTagArray,
        usize,
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        u32,
        *mut *mut SPropProblemArray,
    ) -> windows_core::HRESULT,
    pub GetNamesFromIDs: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut SPropTagArray,
        *mut windows_core::GUID,
        u32,
        *mut u32,
        *mut *mut *mut MAPINAMEID,
    ) -> windows_core::HRESULT,
    pub GetIDsFromNames: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut MAPINAMEID,
        u32,
        *mut *mut SPropTagArray,
    ) -> windows_core::HRESULT,
}
pub trait IMAPIProp_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn SaveChanges(&self, ulflags: u32) -> windows_core::Result<()>;
    fn GetProps(
        &self,
        lpproptagarray: *mut SPropTagArray,
        ulflags: u32,
        lpcvalues: *mut u32,
        lppproparray: *mut *mut SPropValue,
    ) -> windows_core::Result<()>;
    fn GetPropList(
        &self,
        ulflags: u32,
        lppproptagarray: *mut *mut SPropTagArray,
    ) -> windows_core::Result<()>;
    fn OpenProperty(
        &self,
        ulproptag: u32,
        lpiid: *mut windows_core::GUID,
        ulinterfaceoptions: u32,
        ulflags: u32,
        lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
    ) -> windows_core::Result<()>;
    fn SetProps(
        &self,
        cvalues: u32,
        lpproparray: *mut SPropValue,
        lppproblems: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()>;
    fn DeleteProps(
        &self,
        lpproptagarray: *mut SPropTagArray,
        lppproblems: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()>;
    fn CopyTo(
        &self,
        ciidexclude: u32,
        rgiidexclude: *mut windows_core::GUID,
        lpexcludeprops: *mut SPropTagArray,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        lpinterface: *mut windows_core::GUID,
        lpdestobj: *mut core::ffi::c_void,
        ulflags: u32,
        lppproblems: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()>;
    fn CopyProps(
        &self,
        lpincludeprops: *mut SPropTagArray,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        lpinterface: *mut windows_core::GUID,
        lpdestobj: *mut core::ffi::c_void,
        ulflags: u32,
        lppproblems: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()>;
    fn GetNamesFromIDs(
        &self,
        lppproptags: *mut *mut SPropTagArray,
        lppropsetguid: *mut windows_core::GUID,
        ulflags: u32,
        lpcpropnames: *mut u32,
        lppppropnames: *mut *mut *mut MAPINAMEID,
    ) -> windows_core::Result<()>;
    fn GetIDsFromNames(
        &self,
        cpropnames: u32,
        lpppropnames: *mut *mut MAPINAMEID,
        ulflags: u32,
        lppproptags: *mut *mut SPropTagArray,
    ) -> windows_core::Result<()>;
}
impl IMAPIProp_Vtbl {
    pub const fn new<Identity: IMAPIProp_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<Identity: IMAPIProp_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProp_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn SaveChanges<Identity: IMAPIProp_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProp_Impl::SaveChanges(this, core::mem::transmute_copy(&ulflags)).into()
            }
        }
        unsafe extern "system" fn GetProps<Identity: IMAPIProp_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpproptagarray: *mut SPropTagArray,
            ulflags: u32,
            lpcvalues: *mut u32,
            lppproparray: *mut *mut SPropValue,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProp_Impl::GetProps(
                    this,
                    core::mem::transmute_copy(&lpproptagarray),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpcvalues),
                    core::mem::transmute_copy(&lppproparray),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetPropList<Identity: IMAPIProp_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lppproptagarray: *mut *mut SPropTagArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProp_Impl::GetPropList(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppproptagarray),
                )
                .into()
            }
        }
        unsafe extern "system" fn OpenProperty<Identity: IMAPIProp_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulproptag: u32,
            lpiid: *mut windows_core::GUID,
            ulinterfaceoptions: u32,
            ulflags: u32,
            lppunk: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProp_Impl::OpenProperty(
                    this,
                    core::mem::transmute_copy(&ulproptag),
                    core::mem::transmute_copy(&lpiid),
                    core::mem::transmute_copy(&ulinterfaceoptions),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppunk),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetProps<Identity: IMAPIProp_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cvalues: u32,
            lpproparray: *mut SPropValue,
            lppproblems: *mut *mut SPropProblemArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProp_Impl::SetProps(
                    this,
                    core::mem::transmute_copy(&cvalues),
                    core::mem::transmute_copy(&lpproparray),
                    core::mem::transmute_copy(&lppproblems),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteProps<Identity: IMAPIProp_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpproptagarray: *mut SPropTagArray,
            lppproblems: *mut *mut SPropProblemArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProp_Impl::DeleteProps(
                    this,
                    core::mem::transmute_copy(&lpproptagarray),
                    core::mem::transmute_copy(&lppproblems),
                )
                .into()
            }
        }
        unsafe extern "system" fn CopyTo<Identity: IMAPIProp_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ciidexclude: u32,
            rgiidexclude: *mut windows_core::GUID,
            lpexcludeprops: *mut SPropTagArray,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            lpinterface: *mut windows_core::GUID,
            lpdestobj: *mut core::ffi::c_void,
            ulflags: u32,
            lppproblems: *mut *mut SPropProblemArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProp_Impl::CopyTo(
                    this,
                    core::mem::transmute_copy(&ciidexclude),
                    core::mem::transmute_copy(&rgiidexclude),
                    core::mem::transmute_copy(&lpexcludeprops),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&lpdestobj),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppproblems),
                )
                .into()
            }
        }
        unsafe extern "system" fn CopyProps<Identity: IMAPIProp_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpincludeprops: *mut SPropTagArray,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            lpinterface: *mut windows_core::GUID,
            lpdestobj: *mut core::ffi::c_void,
            ulflags: u32,
            lppproblems: *mut *mut SPropProblemArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProp_Impl::CopyProps(
                    this,
                    core::mem::transmute_copy(&lpincludeprops),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&lpdestobj),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppproblems),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetNamesFromIDs<Identity: IMAPIProp_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lppproptags: *mut *mut SPropTagArray,
            lppropsetguid: *mut windows_core::GUID,
            ulflags: u32,
            lpcpropnames: *mut u32,
            lppppropnames: *mut *mut *mut MAPINAMEID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProp_Impl::GetNamesFromIDs(
                    this,
                    core::mem::transmute_copy(&lppproptags),
                    core::mem::transmute_copy(&lppropsetguid),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpcpropnames),
                    core::mem::transmute_copy(&lppppropnames),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetIDsFromNames<Identity: IMAPIProp_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cpropnames: u32,
            lpppropnames: *mut *mut MAPINAMEID,
            ulflags: u32,
            lppproptags: *mut *mut SPropTagArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProp_Impl::GetIDsFromNames(
                    this,
                    core::mem::transmute_copy(&cpropnames),
                    core::mem::transmute_copy(&lpppropnames),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppproptags),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            SaveChanges: SaveChanges::<Identity, OFFSET>,
            GetProps: GetProps::<Identity, OFFSET>,
            GetPropList: GetPropList::<Identity, OFFSET>,
            OpenProperty: OpenProperty::<Identity, OFFSET>,
            SetProps: SetProps::<Identity, OFFSET>,
            DeleteProps: DeleteProps::<Identity, OFFSET>,
            CopyTo: CopyTo::<Identity, OFFSET>,
            CopyProps: CopyProps::<Identity, OFFSET>,
            GetNamesFromIDs: GetNamesFromIDs::<Identity, OFFSET>,
            GetIDsFromNames: GetIDsFromNames::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIProp as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIProp {}
pub const IMAPIProp_CopyProps: METHODS = METHODS(11i32);
pub const IMAPIProp_CopyTo: METHODS = METHODS(10i32);
pub const IMAPIProp_DeleteProps: METHODS = METHODS(9i32);
pub const IMAPIProp_GetIDsFromNames: METHODS = METHODS(13i32);
pub const IMAPIProp_GetLastError: METHODS = METHODS(3i32);
pub const IMAPIProp_GetNamesFromIDs: METHODS = METHODS(12i32);
pub const IMAPIProp_GetPropList: METHODS = METHODS(6i32);
pub const IMAPIProp_GetProps: METHODS = METHODS(5i32);
pub const IMAPIProp_OpenProperty: METHODS = METHODS(7i32);
pub const IMAPIProp_SaveChanges: METHODS = METHODS(4i32);
pub const IMAPIProp_SetProps: METHODS = METHODS(8i32);
windows_core::imp::define_interface!(
    IMAPIProviderShutdown,
    IMAPIProviderShutdown_Vtbl,
    0x00020398_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIProviderShutdown, windows_core::IUnknown);
impl IMAPIProviderShutdown {
    pub unsafe fn QueryFastShutdown(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).QueryFastShutdown)(
                windows_core::Interface::as_raw(self),
            )
            .ok()
        }
    }
    pub unsafe fn NotifyProcessShutdown(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).NotifyProcessShutdown)(
                windows_core::Interface::as_raw(self),
            )
            .ok()
        }
    }
    pub unsafe fn DoFastShutdown(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DoFastShutdown)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIProviderShutdown_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub QueryFastShutdown:
        unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub NotifyProcessShutdown:
        unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub DoFastShutdown: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IMAPIProviderShutdown_Impl: windows_core::IUnknownImpl {
    fn QueryFastShutdown(&self) -> windows_core::Result<()>;
    fn NotifyProcessShutdown(&self) -> windows_core::Result<()>;
    fn DoFastShutdown(&self) -> windows_core::Result<()>;
}
impl IMAPIProviderShutdown_Vtbl {
    pub const fn new<Identity: IMAPIProviderShutdown_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn QueryFastShutdown<
            Identity: IMAPIProviderShutdown_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProviderShutdown_Impl::QueryFastShutdown(this).into()
            }
        }
        unsafe extern "system" fn NotifyProcessShutdown<
            Identity: IMAPIProviderShutdown_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProviderShutdown_Impl::NotifyProcessShutdown(this).into()
            }
        }
        unsafe extern "system" fn DoFastShutdown<
            Identity: IMAPIProviderShutdown_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIProviderShutdown_Impl::DoFastShutdown(this).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            QueryFastShutdown: QueryFastShutdown::<Identity, OFFSET>,
            NotifyProcessShutdown: NotifyProcessShutdown::<Identity, OFFSET>,
            DoFastShutdown: DoFastShutdown::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIProviderShutdown as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIProviderShutdown {}
windows_core::imp::define_interface!(
    IMAPISession,
    IMAPISession_Vtbl,
    0x00020300_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPISession, windows_core::IUnknown);
impl IMAPISession {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMsgStoresTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetMsgStoresTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn OpenMsgStore(
        &self,
        uluiparam: usize,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppmdb: *mut Option<IMsgStore>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenMsgStore)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                cbentryid,
                lpentryid as _,
                lpinterface as _,
                ulflags,
                core::mem::transmute(lppmdb),
            )
            .ok()
        }
    }
    pub unsafe fn OpenAddressBook(
        &self,
        uluiparam: usize,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppadrbook: *mut Option<IAddrBook>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenAddressBook)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                lpinterface as _,
                ulflags,
                core::mem::transmute(lppadrbook),
            )
            .ok()
        }
    }
    pub unsafe fn OpenProfileSection(
        &self,
        lpuid: *mut MAPIUID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppprofsect: *mut Option<IProfSect>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenProfileSection)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                lpinterface as _,
                ulflags,
                core::mem::transmute(lppprofsect),
            )
            .ok()
        }
    }
    pub unsafe fn GetStatusTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetStatusTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppunk: *mut Option<windows_core::IUnknown>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenEntry)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                lpinterface as _,
                ulflags,
                lpulobjtype as _,
                core::mem::transmute(lppunk),
            )
            .ok()
        }
    }
    pub unsafe fn CompareEntryIDs(
        &self,
        cbentryid1: u32,
        lpentryid1: *mut ENTRYID,
        cbentryid2: u32,
        lpentryid2: *mut ENTRYID,
        ulflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CompareEntryIDs)(
                windows_core::Interface::as_raw(self),
                cbentryid1,
                lpentryid1 as _,
                cbentryid2,
                lpentryid2 as _,
                ulflags,
                lpulresult as _,
            )
            .ok()
        }
    }
    pub unsafe fn Advise<P3>(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        uleventmask: u32,
        lpadvisesink: P3,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<IMAPIAdviseSink>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Advise)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                uleventmask,
                lpadvisesink.param().abi(),
                lpulconnection as _,
            )
            .ok()
        }
    }
    pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Unadvise)(
                windows_core::Interface::as_raw(self),
                ulconnection,
            )
            .ok()
        }
    }
    pub unsafe fn MessageOptions<P3>(
        &self,
        uluiparam: usize,
        ulflags: u32,
        lpszadrtype: *mut i8,
        lpmessage: P3,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).MessageOptions)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                lpszadrtype as _,
                lpmessage.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn QueryDefaultMessageOpt(
        &self,
        lpszadrtype: *mut i8,
        ulflags: u32,
        lpcvalues: *mut u32,
        lppoptions: *mut *mut SPropValue,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).QueryDefaultMessageOpt)(
                windows_core::Interface::as_raw(self),
                lpszadrtype as _,
                ulflags,
                lpcvalues as _,
                lppoptions as _,
            )
            .ok()
        }
    }
    pub unsafe fn EnumAdrTypes(
        &self,
        ulflags: u32,
        lpcadrtypes: *mut u32,
        lpppszadrtypes: *mut *mut *mut i8,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).EnumAdrTypes)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpcadrtypes as _,
                lpppszadrtypes as _,
            )
            .ok()
        }
    }
    pub unsafe fn QueryIdentity(
        &self,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).QueryIdentity)(
                windows_core::Interface::as_raw(self),
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn Logoff(
        &self,
        uluiparam: usize,
        ulflags: u32,
        ulreserved: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Logoff)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                ulreserved,
            )
            .ok()
        }
    }
    pub unsafe fn SetDefaultStore(
        &self,
        ulflags: u32,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetDefaultStore)(
                windows_core::Interface::as_raw(self),
                ulflags,
                cbentryid,
                lpentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn AdminServices(&self, ulflags: u32) -> windows_core::Result<IMsgServiceAdmin> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).AdminServices)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn ShowForm<P1, P2, P5, P10>(
        &self,
        uluiparam: usize,
        lpmsgstore: P1,
        lpparentfolder: P2,
        lpinterface: *mut windows_core::GUID,
        ulmessagetoken: usize,
        lpmessagesent: P5,
        ulflags: u32,
        ulmessagestatus: u32,
        ulmessageflags: u32,
        ulaccess: u32,
        lpszmessageclass: P10,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<IMsgStore>,
        P2: windows_core::Param<IMAPIFolder>,
        P5: windows_core::Param<IMessage>,
        P10: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).ShowForm)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                lpmsgstore.param().abi(),
                lpparentfolder.param().abi(),
                lpinterface as _,
                ulmessagetoken,
                lpmessagesent.param().abi(),
                ulflags,
                ulmessagestatus,
                ulmessageflags,
                ulaccess,
                lpszmessageclass.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn PrepareForm<P1>(
        &self,
        lpinterface: *mut windows_core::GUID,
        lpmessage: P1,
        lpulmessagetoken: *mut usize,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).PrepareForm)(
                windows_core::Interface::as_raw(self),
                lpinterface as _,
                lpmessage.param().abi(),
                lpulmessagetoken as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPISession_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub GetMsgStoresTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub OpenMsgStore: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut ENTRYID,
        *mut windows_core::GUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub OpenAddressBook: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        *mut windows_core::GUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub OpenProfileSection: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        *mut windows_core::GUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetStatusTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub OpenEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        *mut windows_core::GUID,
        u32,
        *mut u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CompareEntryIDs: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut ENTRYID,
        u32,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub Advise: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut core::ffi::c_void,
        *mut usize,
    ) -> windows_core::HRESULT,
    pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
    pub MessageOptions: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut i8,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub QueryDefaultMessageOpt: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        u32,
        *mut u32,
        *mut *mut SPropValue,
    ) -> windows_core::HRESULT,
    pub EnumAdrTypes: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut u32,
        *mut *mut *mut i8,
    ) -> windows_core::HRESULT,
    pub QueryIdentity: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub Logoff:
        unsafe extern "system" fn(*mut core::ffi::c_void, usize, u32, u32) -> windows_core::HRESULT,
    pub SetDefaultStore: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub AdminServices: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ShowForm: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        usize,
        *mut core::ffi::c_void,
        u32,
        u32,
        u32,
        u32,
        windows_core::PCSTR,
    ) -> windows_core::HRESULT,
    pub PrepareForm: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        *mut usize,
    ) -> windows_core::HRESULT,
}
pub trait IMAPISession_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn GetMsgStoresTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn OpenMsgStore(
        &self,
        uluiparam: usize,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppmdb: windows_core::OutRef<'_, IMsgStore>,
    ) -> windows_core::Result<()>;
    fn OpenAddressBook(
        &self,
        uluiparam: usize,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppadrbook: windows_core::OutRef<'_, IAddrBook>,
    ) -> windows_core::Result<()>;
    fn OpenProfileSection(
        &self,
        lpuid: *mut MAPIUID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppprofsect: windows_core::OutRef<'_, IProfSect>,
    ) -> windows_core::Result<()>;
    fn GetStatusTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
    ) -> windows_core::Result<()>;
    fn CompareEntryIDs(
        &self,
        cbentryid1: u32,
        lpentryid1: *mut ENTRYID,
        cbentryid2: u32,
        lpentryid2: *mut ENTRYID,
        ulflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()>;
    fn Advise(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        uleventmask: u32,
        lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>;
    fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
    fn MessageOptions(
        &self,
        uluiparam: usize,
        ulflags: u32,
        lpszadrtype: *mut i8,
        lpmessage: windows_core::Ref<'_, IMessage>,
    ) -> windows_core::Result<()>;
    fn QueryDefaultMessageOpt(
        &self,
        lpszadrtype: *mut i8,
        ulflags: u32,
        lpcvalues: *mut u32,
        lppoptions: *mut *mut SPropValue,
    ) -> windows_core::Result<()>;
    fn EnumAdrTypes(
        &self,
        ulflags: u32,
        lpcadrtypes: *mut u32,
        lpppszadrtypes: *mut *mut *mut i8,
    ) -> windows_core::Result<()>;
    fn QueryIdentity(
        &self,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn Logoff(&self, uluiparam: usize, ulflags: u32, ulreserved: u32) -> windows_core::Result<()>;
    fn SetDefaultStore(
        &self,
        ulflags: u32,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn AdminServices(&self, ulflags: u32) -> windows_core::Result<IMsgServiceAdmin>;
    fn ShowForm(
        &self,
        uluiparam: usize,
        lpmsgstore: windows_core::Ref<'_, IMsgStore>,
        lpparentfolder: windows_core::Ref<'_, IMAPIFolder>,
        lpinterface: *mut windows_core::GUID,
        ulmessagetoken: usize,
        lpmessagesent: windows_core::Ref<'_, IMessage>,
        ulflags: u32,
        ulmessagestatus: u32,
        ulmessageflags: u32,
        ulaccess: u32,
        lpszmessageclass: &windows_core::PCSTR,
    ) -> windows_core::Result<()>;
    fn PrepareForm(
        &self,
        lpinterface: *mut windows_core::GUID,
        lpmessage: windows_core::Ref<'_, IMessage>,
        lpulmessagetoken: *mut usize,
    ) -> windows_core::Result<()>;
}
impl IMAPISession_Vtbl {
    pub const fn new<Identity: IMAPISession_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<Identity: IMAPISession_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMsgStoresTable<
            Identity: IMAPISession_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPISession_Impl::GetMsgStoresTable(
                    this,
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn OpenMsgStore<Identity: IMAPISession_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lppmdb: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::OpenMsgStore(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmdb),
                )
                .into()
            }
        }
        unsafe extern "system" fn OpenAddressBook<
            Identity: IMAPISession_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lppadrbook: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::OpenAddressBook(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppadrbook),
                )
                .into()
            }
        }
        unsafe extern "system" fn OpenProfileSection<
            Identity: IMAPISession_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lppprofsect: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::OpenProfileSection(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppprofsect),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetStatusTable<
            Identity: IMAPISession_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPISession_Impl::GetStatusTable(this, core::mem::transmute_copy(&ulflags)) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn OpenEntry<Identity: IMAPISession_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lpulobjtype: *mut u32,
            lppunk: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::OpenEntry(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulobjtype),
                    core::mem::transmute_copy(&lppunk),
                )
                .into()
            }
        }
        unsafe extern "system" fn CompareEntryIDs<
            Identity: IMAPISession_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cbentryid1: u32,
            lpentryid1: *mut ENTRYID,
            cbentryid2: u32,
            lpentryid2: *mut ENTRYID,
            ulflags: u32,
            lpulresult: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::CompareEntryIDs(
                    this,
                    core::mem::transmute_copy(&cbentryid1),
                    core::mem::transmute_copy(&lpentryid1),
                    core::mem::transmute_copy(&cbentryid2),
                    core::mem::transmute_copy(&lpentryid2),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulresult),
                )
                .into()
            }
        }
        unsafe extern "system" fn Advise<Identity: IMAPISession_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            uleventmask: u32,
            lpadvisesink: *mut core::ffi::c_void,
            lpulconnection: *mut usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::Advise(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&uleventmask),
                    core::mem::transmute_copy(&lpadvisesink),
                    core::mem::transmute_copy(&lpulconnection),
                )
                .into()
            }
        }
        unsafe extern "system" fn Unadvise<Identity: IMAPISession_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulconnection: usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
            }
        }
        unsafe extern "system" fn MessageOptions<
            Identity: IMAPISession_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            lpszadrtype: *mut i8,
            lpmessage: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::MessageOptions(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpszadrtype),
                    core::mem::transmute_copy(&lpmessage),
                )
                .into()
            }
        }
        unsafe extern "system" fn QueryDefaultMessageOpt<
            Identity: IMAPISession_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszadrtype: *mut i8,
            ulflags: u32,
            lpcvalues: *mut u32,
            lppoptions: *mut *mut SPropValue,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::QueryDefaultMessageOpt(
                    this,
                    core::mem::transmute_copy(&lpszadrtype),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpcvalues),
                    core::mem::transmute_copy(&lppoptions),
                )
                .into()
            }
        }
        unsafe extern "system" fn EnumAdrTypes<Identity: IMAPISession_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpcadrtypes: *mut u32,
            lpppszadrtypes: *mut *mut *mut i8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::EnumAdrTypes(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpcadrtypes),
                    core::mem::transmute_copy(&lpppszadrtypes),
                )
                .into()
            }
        }
        unsafe extern "system" fn QueryIdentity<
            Identity: IMAPISession_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::QueryIdentity(
                    this,
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn Logoff<Identity: IMAPISession_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            ulreserved: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::Logoff(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&ulreserved),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetDefaultStore<
            Identity: IMAPISession_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::SetDefaultStore(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn AdminServices<
            Identity: IMAPISession_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lppserviceadmin: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPISession_Impl::AdminServices(this, core::mem::transmute_copy(&ulflags)) {
                    Ok(ok__) => {
                        lppserviceadmin.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn ShowForm<Identity: IMAPISession_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            lpmsgstore: *mut core::ffi::c_void,
            lpparentfolder: *mut core::ffi::c_void,
            lpinterface: *mut windows_core::GUID,
            ulmessagetoken: usize,
            lpmessagesent: *mut core::ffi::c_void,
            ulflags: u32,
            ulmessagestatus: u32,
            ulmessageflags: u32,
            ulaccess: u32,
            lpszmessageclass: windows_core::PCSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::ShowForm(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpmsgstore),
                    core::mem::transmute_copy(&lpparentfolder),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulmessagetoken),
                    core::mem::transmute_copy(&lpmessagesent),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&ulmessagestatus),
                    core::mem::transmute_copy(&ulmessageflags),
                    core::mem::transmute_copy(&ulaccess),
                    core::mem::transmute(&lpszmessageclass),
                )
                .into()
            }
        }
        unsafe extern "system" fn PrepareForm<Identity: IMAPISession_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpinterface: *mut windows_core::GUID,
            lpmessage: *mut core::ffi::c_void,
            lpulmessagetoken: *mut usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISession_Impl::PrepareForm(
                    this,
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&lpmessage),
                    core::mem::transmute_copy(&lpulmessagetoken),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            GetMsgStoresTable: GetMsgStoresTable::<Identity, OFFSET>,
            OpenMsgStore: OpenMsgStore::<Identity, OFFSET>,
            OpenAddressBook: OpenAddressBook::<Identity, OFFSET>,
            OpenProfileSection: OpenProfileSection::<Identity, OFFSET>,
            GetStatusTable: GetStatusTable::<Identity, OFFSET>,
            OpenEntry: OpenEntry::<Identity, OFFSET>,
            CompareEntryIDs: CompareEntryIDs::<Identity, OFFSET>,
            Advise: Advise::<Identity, OFFSET>,
            Unadvise: Unadvise::<Identity, OFFSET>,
            MessageOptions: MessageOptions::<Identity, OFFSET>,
            QueryDefaultMessageOpt: QueryDefaultMessageOpt::<Identity, OFFSET>,
            EnumAdrTypes: EnumAdrTypes::<Identity, OFFSET>,
            QueryIdentity: QueryIdentity::<Identity, OFFSET>,
            Logoff: Logoff::<Identity, OFFSET>,
            SetDefaultStore: SetDefaultStore::<Identity, OFFSET>,
            AdminServices: AdminServices::<Identity, OFFSET>,
            ShowForm: ShowForm::<Identity, OFFSET>,
            PrepareForm: PrepareForm::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPISession as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPISession {}
windows_core::imp::define_interface!(
    IMAPIStatus,
    IMAPIStatus_Vtbl,
    0x00020305_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMAPIStatus {
    type Target = IMAPIProp;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(IMAPIStatus, windows_core::IUnknown, IMAPIProp);
impl IMAPIStatus {
    pub unsafe fn ValidateState(&self, uluiparam: usize, ulflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ValidateState)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn SettingsDialog(
        &self,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SettingsDialog)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn ChangePassword(
        &self,
        lpoldpass: *mut i8,
        lpnewpass: *mut i8,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ChangePassword)(
                windows_core::Interface::as_raw(self),
                lpoldpass as _,
                lpnewpass as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn FlushQueues(
        &self,
        uluiparam: usize,
        cbtargettransport: u32,
        lptargettransport: *mut ENTRYID,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FlushQueues)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                cbtargettransport,
                lptargettransport as _,
                ulflags,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIStatus_Vtbl {
    pub base__: IMAPIProp_Vtbl,
    pub ValidateState:
        unsafe extern "system" fn(*mut core::ffi::c_void, usize, u32) -> windows_core::HRESULT,
    pub SettingsDialog:
        unsafe extern "system" fn(*mut core::ffi::c_void, usize, u32) -> windows_core::HRESULT,
    pub ChangePassword: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        *mut i8,
        u32,
    ) -> windows_core::HRESULT,
    pub FlushQueues: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut ENTRYID,
        u32,
    ) -> windows_core::HRESULT,
}
pub trait IMAPIStatus_Impl: IMAPIProp_Impl {
    fn ValidateState(&self, uluiparam: usize, ulflags: u32) -> windows_core::Result<()>;
    fn SettingsDialog(&self, uluiparam: usize, ulflags: u32) -> windows_core::Result<()>;
    fn ChangePassword(
        &self,
        lpoldpass: *mut i8,
        lpnewpass: *mut i8,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn FlushQueues(
        &self,
        uluiparam: usize,
        cbtargettransport: u32,
        lptargettransport: *mut ENTRYID,
        ulflags: u32,
    ) -> windows_core::Result<()>;
}
impl IMAPIStatus_Vtbl {
    pub const fn new<Identity: IMAPIStatus_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn ValidateState<Identity: IMAPIStatus_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIStatus_Impl::ValidateState(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn SettingsDialog<
            Identity: IMAPIStatus_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIStatus_Impl::SettingsDialog(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn ChangePassword<
            Identity: IMAPIStatus_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpoldpass: *mut i8,
            lpnewpass: *mut i8,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIStatus_Impl::ChangePassword(
                    this,
                    core::mem::transmute_copy(&lpoldpass),
                    core::mem::transmute_copy(&lpnewpass),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn FlushQueues<Identity: IMAPIStatus_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            cbtargettransport: u32,
            lptargettransport: *mut ENTRYID,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIStatus_Impl::FlushQueues(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&cbtargettransport),
                    core::mem::transmute_copy(&lptargettransport),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        Self {
            base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
            ValidateState: ValidateState::<Identity, OFFSET>,
            SettingsDialog: SettingsDialog::<Identity, OFFSET>,
            ChangePassword: ChangePassword::<Identity, OFFSET>,
            FlushQueues: FlushQueues::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIStatus as windows_core::Interface>::IID
            || iid == &<IMAPIProp as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIStatus {}
pub const IMAPIStatus_ChangePassword: METHODS = METHODS(124i32);
pub const IMAPIStatus_FlushQueues: METHODS = METHODS(125i32);
pub const IMAPIStatus_SettingsDialog: METHODS = METHODS(123i32);
pub const IMAPIStatus_ValidateState: METHODS = METHODS(122i32);
windows_core::imp::define_interface!(IMAPISupport, IMAPISupport_Vtbl, 0);
windows_core::imp::interface_hierarchy!(IMAPISupport, windows_core::IUnknown);
impl IMAPISupport {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMemAllocRoutines(
        &self,
        lpallocatebuffer: *mut LPALLOCATEBUFFER,
        lpallocatemore: *mut LPALLOCATEMORE,
        lpfreebuffer: *mut LPFREEBUFFER,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetMemAllocRoutines)(
                windows_core::Interface::as_raw(self),
                lpallocatebuffer as _,
                lpallocatemore as _,
                lpfreebuffer as _,
            )
            .ok()
        }
    }
    pub unsafe fn Subscribe<P3>(
        &self,
        lpkey: *mut NOTIFKEY,
        uleventmask: u32,
        ulflags: u32,
        lpadvisesink: P3,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<IMAPIAdviseSink>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Subscribe)(
                windows_core::Interface::as_raw(self),
                lpkey as _,
                uleventmask,
                ulflags,
                lpadvisesink.param().abi(),
                lpulconnection as _,
            )
            .ok()
        }
    }
    pub unsafe fn Unsubscribe(&self, ulconnection: usize) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Unsubscribe)(
                windows_core::Interface::as_raw(self),
                ulconnection,
            )
            .ok()
        }
    }
    pub unsafe fn Notify(
        &self,
        lpkey: *mut NOTIFKEY,
        cnotification: u32,
        lpnotifications: *mut NOTIFICATION,
        lpulflags: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Notify)(
                windows_core::Interface::as_raw(self),
                lpkey as _,
                cnotification,
                lpnotifications as _,
                lpulflags as _,
            )
            .ok()
        }
    }
    pub unsafe fn ModifyStatusRow(
        &self,
        cvalues: u32,
        lpcolumnvals: *mut SPropValue,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ModifyStatusRow)(
                windows_core::Interface::as_raw(self),
                cvalues,
                lpcolumnvals as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn OpenProfileSection(
        &self,
        lpuid: *mut MAPIUID,
        ulflags: u32,
        lppprofileobj: *mut Option<IProfSect>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenProfileSection)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                ulflags,
                core::mem::transmute(lppprofileobj),
            )
            .ok()
        }
    }
    pub unsafe fn RegisterPreprocessor<P3, P4>(
        &self,
        lpmuid: *mut MAPIUID,
        lpszadrtype: *mut i8,
        lpszdllname: *mut i8,
        lpszpreprocess: P3,
        lpszremovepreprocessinfo: P4,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<windows_core::PCSTR>,
        P4: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).RegisterPreprocessor)(
                windows_core::Interface::as_raw(self),
                lpmuid as _,
                lpszadrtype as _,
                lpszdllname as _,
                lpszpreprocess.param().abi(),
                lpszremovepreprocessinfo.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn NewUID(&self, lpmuid: *mut MAPIUID) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).NewUID)(
                windows_core::Interface::as_raw(self),
                lpmuid as _,
            )
            .ok()
        }
    }
    pub unsafe fn MakeInvalid(
        &self,
        ulflags: u32,
        lpobject: *mut core::ffi::c_void,
        ulrefcount: u32,
        cmethods: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).MakeInvalid)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpobject as _,
                ulrefcount,
                cmethods,
            )
            .ok()
        }
    }
    pub unsafe fn SpoolerYield(&self, ulflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SpoolerYield)(
                windows_core::Interface::as_raw(self),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn SpoolerNotify(
        &self,
        ulflags: u32,
        lpvdata: *mut core::ffi::c_void,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SpoolerNotify)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpvdata as _,
            )
            .ok()
        }
    }
    pub unsafe fn CreateOneOff(
        &self,
        lpszname: *mut i8,
        lpszadrtype: *mut i8,
        lpszaddress: *mut i8,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CreateOneOff)(
                windows_core::Interface::as_raw(self),
                lpszname as _,
                lpszadrtype as _,
                lpszaddress as _,
                ulflags,
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetProviderUID(
        &self,
        lpproviderid: *mut MAPIUID,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetProviderUID)(
                windows_core::Interface::as_raw(self),
                lpproviderid as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn CompareEntryIDs(
        &self,
        cbentry1: u32,
        lpentry1: *mut ENTRYID,
        cbentry2: u32,
        lpentry2: *mut ENTRYID,
        ulcompareflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CompareEntryIDs)(
                windows_core::Interface::as_raw(self),
                cbentry1,
                lpentry1 as _,
                cbentry2,
                lpentry2 as _,
                ulcompareflags,
                lpulresult as _,
            )
            .ok()
        }
    }
    pub unsafe fn OpenTemplateID<P3, P6>(
        &self,
        cbtemplateid: u32,
        lptemplateid: *mut ENTRYID,
        ultemplateflags: u32,
        lpmapipropdata: P3,
        lpinterface: *mut windows_core::GUID,
        lppmapipropnew: *mut Option<IMAPIProp>,
        lpmapipropsibling: P6,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<IMAPIProp>,
        P6: windows_core::Param<IMAPIProp>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).OpenTemplateID)(
                windows_core::Interface::as_raw(self),
                cbtemplateid,
                lptemplateid as _,
                ultemplateflags,
                lpmapipropdata.param().abi(),
                lpinterface as _,
                core::mem::transmute(lppmapipropnew),
                lpmapipropsibling.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulopenflags: u32,
        lpulobjtype: *mut u32,
        lppunk: *mut Option<windows_core::IUnknown>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenEntry)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                lpinterface as _,
                ulopenflags,
                lpulobjtype as _,
                core::mem::transmute(lppunk),
            )
            .ok()
        }
    }
    pub unsafe fn GetOneOffTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetOneOffTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn Address(
        &self,
        lpuluiparam: *mut usize,
        lpadrparms: *mut ADRPARM,
        lppadrlist: *mut *mut ADRLIST,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Address)(
                windows_core::Interface::as_raw(self),
                lpuluiparam as _,
                lpadrparms as _,
                lppadrlist as _,
            )
            .ok()
        }
    }
    pub unsafe fn Details(
        &self,
        lpuluiparam: *mut usize,
        lpfndismiss: LPFNDISMISS,
        lpvdismisscontext: *mut core::ffi::c_void,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
        lpvbuttoncontext: *mut core::ffi::c_void,
        lpszbuttontext: *mut i8,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Details)(
                windows_core::Interface::as_raw(self),
                lpuluiparam as _,
                lpfndismiss,
                lpvdismisscontext as _,
                cbentryid,
                lpentryid as _,
                lpfbuttoncallback,
                lpvbuttoncontext as _,
                lpszbuttontext as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn NewEntry(
        &self,
        uluiparam: usize,
        ulflags: u32,
        cbeidcontainer: u32,
        lpeidcontainer: *mut ENTRYID,
        cbeidnewentrytpl: u32,
        lpeidnewentrytpl: *mut ENTRYID,
        lpcbeidnewentry: *mut u32,
        lppeidnewentry: *mut *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).NewEntry)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                cbeidcontainer,
                lpeidcontainer as _,
                cbeidnewentrytpl,
                lpeidnewentrytpl as _,
                lpcbeidnewentry as _,
                lppeidnewentry as _,
            )
            .ok()
        }
    }
    pub unsafe fn DoConfigPropsheet<P3, P4>(
        &self,
        uluiparam: usize,
        ulflags: u32,
        lpsztitle: *mut i8,
        lpdisplaytable: P3,
        lpconfigdata: P4,
        ultoppage: u32,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<IMAPITable>,
        P4: windows_core::Param<IMAPIProp>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DoConfigPropsheet)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                lpsztitle as _,
                lpdisplaytable.param().abi(),
                lpconfigdata.param().abi(),
                ultoppage,
            )
            .ok()
        }
    }
    pub unsafe fn CopyMessages<P6>(
        &self,
        lpsrcinterface: *mut windows_core::GUID,
        lpsrcfolder: *mut core::ffi::c_void,
        lpmsglist: *mut SBinaryArray,
        lpdestinterface: *mut windows_core::GUID,
        lpdestfolder: *mut core::ffi::c_void,
        uluiparam: usize,
        lpprogress: P6,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P6: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CopyMessages)(
                windows_core::Interface::as_raw(self),
                lpsrcinterface as _,
                lpsrcfolder as _,
                lpmsglist as _,
                lpdestinterface as _,
                lpdestfolder as _,
                uluiparam,
                lpprogress.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn CopyFolder<P8>(
        &self,
        lpsrcinterface: *mut windows_core::GUID,
        lpsrcfolder: *mut core::ffi::c_void,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpdestinterface: *mut windows_core::GUID,
        lpdestfolder: *mut core::ffi::c_void,
        lsznewfoldername: *mut i8,
        uluiparam: usize,
        lpprogress: P8,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P8: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CopyFolder)(
                windows_core::Interface::as_raw(self),
                lpsrcinterface as _,
                lpsrcfolder as _,
                cbentryid,
                lpentryid as _,
                lpdestinterface as _,
                lpdestfolder as _,
                lsznewfoldername as _,
                uluiparam,
                lpprogress.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn DoCopyTo<P6>(
        &self,
        lpsrcinterface: *mut windows_core::GUID,
        lpsrcobj: *mut core::ffi::c_void,
        ciidexclude: u32,
        rgiidexclude: *mut windows_core::GUID,
        lpexcludeprops: *mut SPropTagArray,
        uluiparam: usize,
        lpprogress: P6,
        lpdestinterface: *mut windows_core::GUID,
        lpdestobj: *mut core::ffi::c_void,
        ulflags: u32,
        lppproblems: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()>
    where
        P6: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DoCopyTo)(
                windows_core::Interface::as_raw(self),
                lpsrcinterface as _,
                lpsrcobj as _,
                ciidexclude,
                rgiidexclude as _,
                lpexcludeprops as _,
                uluiparam,
                lpprogress.param().abi(),
                lpdestinterface as _,
                lpdestobj as _,
                ulflags,
                lppproblems as _,
            )
            .ok()
        }
    }
    pub unsafe fn DoCopyProps<P4>(
        &self,
        lpsrcinterface: *mut windows_core::GUID,
        lpsrcobj: *mut core::ffi::c_void,
        lpincludeprops: *mut SPropTagArray,
        uluiparam: usize,
        lpprogress: P4,
        lpdestinterface: *mut windows_core::GUID,
        lpdestobj: *mut core::ffi::c_void,
        ulflags: u32,
        lppproblems: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()>
    where
        P4: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DoCopyProps)(
                windows_core::Interface::as_raw(self),
                lpsrcinterface as _,
                lpsrcobj as _,
                lpincludeprops as _,
                uluiparam,
                lpprogress.param().abi(),
                lpdestinterface as _,
                lpdestobj as _,
                ulflags,
                lppproblems as _,
            )
            .ok()
        }
    }
    pub unsafe fn DoProgressDialog(
        &self,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<IMAPIProgress> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).DoProgressDialog)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn ReadReceipt<P1>(
        &self,
        ulflags: u32,
        lpreadmessage: P1,
    ) -> windows_core::Result<IMessage>
    where
        P1: windows_core::Param<IMessage>,
    {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).ReadReceipt)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpreadmessage.param().abi(),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn PrepareSubmit<P0>(
        &self,
        lpmessage: P0,
        lpulflags: *mut u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).PrepareSubmit)(
                windows_core::Interface::as_raw(self),
                lpmessage.param().abi(),
                lpulflags as _,
            )
            .ok()
        }
    }
    pub unsafe fn ExpandRecips<P0>(
        &self,
        lpmessage: P0,
        lpulflags: *mut u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).ExpandRecips)(
                windows_core::Interface::as_raw(self),
                lpmessage.param().abi(),
                lpulflags as _,
            )
            .ok()
        }
    }
    pub unsafe fn UpdatePAB<P1>(&self, ulflags: u32, lpmessage: P1) -> windows_core::Result<()>
    where
        P1: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).UpdatePAB)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpmessage.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn DoSentMail<P1>(&self, ulflags: u32, lpmessage: P1) -> windows_core::Result<()>
    where
        P1: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DoSentMail)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpmessage.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn OpenAddressBook(
        &self,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppadrbook: *mut Option<IAddrBook>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenAddressBook)(
                windows_core::Interface::as_raw(self),
                lpinterface as _,
                ulflags,
                core::mem::transmute(lppadrbook),
            )
            .ok()
        }
    }
    pub unsafe fn Preprocess(
        &self,
        ulflags: u32,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Preprocess)(
                windows_core::Interface::as_raw(self),
                ulflags,
                cbentryid,
                lpentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn CompleteMsg(
        &self,
        ulflags: u32,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CompleteMsg)(
                windows_core::Interface::as_raw(self),
                ulflags,
                cbentryid,
                lpentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn StoreLogoffTransports(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).StoreLogoffTransports)(
                windows_core::Interface::as_raw(self),
                lpulflags as _,
            )
            .ok()
        }
    }
    pub unsafe fn StatusRecips<P0>(
        &self,
        lpmessage: P0,
        lpreciplist: *mut ADRLIST,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).StatusRecips)(
                windows_core::Interface::as_raw(self),
                lpmessage.param().abi(),
                lpreciplist as _,
            )
            .ok()
        }
    }
    pub unsafe fn WrapStoreEntryID(
        &self,
        cborigentry: u32,
        lporigentry: *mut ENTRYID,
        lpcbwrappedentry: *mut u32,
        lppwrappedentry: *mut *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).WrapStoreEntryID)(
                windows_core::Interface::as_raw(self),
                cborigentry,
                lporigentry as _,
                lpcbwrappedentry as _,
                lppwrappedentry as _,
            )
            .ok()
        }
    }
    pub unsafe fn ModifyProfile(&self, ulflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ModifyProfile)(
                windows_core::Interface::as_raw(self),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn IStorageFromStream<P0>(
        &self,
        lpunkin: P0,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppstorageout: *mut Option<windows::Win32::System::Com::StructuredStorage::IStorage>,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::IUnknown>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).IStorageFromStream)(
                windows_core::Interface::as_raw(self),
                lpunkin.param().abi(),
                lpinterface as _,
                ulflags,
                core::mem::transmute(lppstorageout),
            )
            .ok()
        }
    }
    pub unsafe fn GetSvcConfigSupportObj(
        &self,
        ulflags: u32,
    ) -> windows_core::Result<IMAPISupport> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetSvcConfigSupportObj)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
}
#[repr(C)]
pub struct IMAPISupport_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub GetMemAllocRoutines: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut LPALLOCATEBUFFER,
        *mut LPALLOCATEMORE,
        *mut LPFREEBUFFER,
    ) -> windows_core::HRESULT,
    pub Subscribe: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut NOTIFKEY,
        u32,
        u32,
        *mut core::ffi::c_void,
        *mut usize,
    ) -> windows_core::HRESULT,
    pub Unsubscribe:
        unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
    pub Notify: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut NOTIFKEY,
        u32,
        *mut NOTIFICATION,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub ModifyStatusRow: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut SPropValue,
        u32,
    ) -> windows_core::HRESULT,
    pub OpenProfileSection: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub RegisterPreprocessor: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        *mut i8,
        *mut i8,
        windows_core::PCSTR,
        windows_core::PCSTR,
        u32,
    ) -> windows_core::HRESULT,
    pub NewUID:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut MAPIUID) -> windows_core::HRESULT,
    pub MakeInvalid: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
        u32,
        u32,
    ) -> windows_core::HRESULT,
    pub SpoolerYield:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub SpoolerNotify: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CreateOneOff: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        *mut i8,
        *mut i8,
        u32,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub SetProviderUID: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        u32,
    ) -> windows_core::HRESULT,
    pub CompareEntryIDs: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut ENTRYID,
        u32,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub OpenTemplateID: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        *mut *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub OpenEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        *mut windows_core::GUID,
        u32,
        *mut u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetOneOffTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Address: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut usize,
        *mut ADRPARM,
        *mut *mut ADRLIST,
    ) -> windows_core::HRESULT,
    pub Details: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut usize,
        LPFNDISMISS,
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        windows::Win32::System::AddressBook::LPFNBUTTON,
        *mut core::ffi::c_void,
        *mut i8,
        u32,
    ) -> windows_core::HRESULT,
    pub NewEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        u32,
        *mut ENTRYID,
        u32,
        *mut ENTRYID,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub DoConfigPropsheet: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut i8,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub CopyMessages: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        *mut SBinaryArray,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        usize,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub CopyFolder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        *mut i8,
        usize,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub DoCopyTo: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        u32,
        *mut windows_core::GUID,
        *mut SPropTagArray,
        usize,
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        u32,
        *mut *mut SPropProblemArray,
    ) -> windows_core::HRESULT,
    pub DoCopyProps: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        *mut SPropTagArray,
        usize,
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        u32,
        *mut *mut SPropProblemArray,
    ) -> windows_core::HRESULT,
    pub DoProgressDialog: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ReadReceipt: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub PrepareSubmit: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub ExpandRecips: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub UpdatePAB: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub DoSentMail: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub OpenAddressBook: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Preprocess: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub CompleteMsg: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub StoreLogoffTransports:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub StatusRecips: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut ADRLIST,
    ) -> windows_core::HRESULT,
    pub WrapStoreEntryID: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        *mut u32,
        *mut *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub ModifyProfile:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub IStorageFromStream: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetSvcConfigSupportObj: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMAPISupport_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn GetMemAllocRoutines(
        &self,
        lpallocatebuffer: *mut LPALLOCATEBUFFER,
        lpallocatemore: *mut LPALLOCATEMORE,
        lpfreebuffer: *mut LPFREEBUFFER,
    ) -> windows_core::Result<()>;
    fn Subscribe(
        &self,
        lpkey: *mut NOTIFKEY,
        uleventmask: u32,
        ulflags: u32,
        lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>;
    fn Unsubscribe(&self, ulconnection: usize) -> windows_core::Result<()>;
    fn Notify(
        &self,
        lpkey: *mut NOTIFKEY,
        cnotification: u32,
        lpnotifications: *mut NOTIFICATION,
        lpulflags: *mut u32,
    ) -> windows_core::Result<()>;
    fn ModifyStatusRow(
        &self,
        cvalues: u32,
        lpcolumnvals: *mut SPropValue,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn OpenProfileSection(
        &self,
        lpuid: *mut MAPIUID,
        ulflags: u32,
        lppprofileobj: windows_core::OutRef<'_, IProfSect>,
    ) -> windows_core::Result<()>;
    fn RegisterPreprocessor(
        &self,
        lpmuid: *mut MAPIUID,
        lpszadrtype: *mut i8,
        lpszdllname: *mut i8,
        lpszpreprocess: &windows_core::PCSTR,
        lpszremovepreprocessinfo: &windows_core::PCSTR,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn NewUID(&self, lpmuid: *mut MAPIUID) -> windows_core::Result<()>;
    fn MakeInvalid(
        &self,
        ulflags: u32,
        lpobject: *mut core::ffi::c_void,
        ulrefcount: u32,
        cmethods: u32,
    ) -> windows_core::Result<()>;
    fn SpoolerYield(&self, ulflags: u32) -> windows_core::Result<()>;
    fn SpoolerNotify(
        &self,
        ulflags: u32,
        lpvdata: *mut core::ffi::c_void,
    ) -> windows_core::Result<()>;
    fn CreateOneOff(
        &self,
        lpszname: *mut i8,
        lpszadrtype: *mut i8,
        lpszaddress: *mut i8,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn SetProviderUID(&self, lpproviderid: *mut MAPIUID, ulflags: u32) -> windows_core::Result<()>;
    fn CompareEntryIDs(
        &self,
        cbentry1: u32,
        lpentry1: *mut ENTRYID,
        cbentry2: u32,
        lpentry2: *mut ENTRYID,
        ulcompareflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()>;
    fn OpenTemplateID(
        &self,
        cbtemplateid: u32,
        lptemplateid: *mut ENTRYID,
        ultemplateflags: u32,
        lpmapipropdata: windows_core::Ref<'_, IMAPIProp>,
        lpinterface: *mut windows_core::GUID,
        lppmapipropnew: windows_core::OutRef<'_, IMAPIProp>,
        lpmapipropsibling: windows_core::Ref<'_, IMAPIProp>,
    ) -> windows_core::Result<()>;
    fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulopenflags: u32,
        lpulobjtype: *mut u32,
        lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
    ) -> windows_core::Result<()>;
    fn GetOneOffTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn Address(
        &self,
        lpuluiparam: *mut usize,
        lpadrparms: *mut ADRPARM,
        lppadrlist: *mut *mut ADRLIST,
    ) -> windows_core::Result<()>;
    fn Details(
        &self,
        lpuluiparam: *mut usize,
        lpfndismiss: LPFNDISMISS,
        lpvdismisscontext: *mut core::ffi::c_void,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
        lpvbuttoncontext: *mut core::ffi::c_void,
        lpszbuttontext: *mut i8,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn NewEntry(
        &self,
        uluiparam: usize,
        ulflags: u32,
        cbeidcontainer: u32,
        lpeidcontainer: *mut ENTRYID,
        cbeidnewentrytpl: u32,
        lpeidnewentrytpl: *mut ENTRYID,
        lpcbeidnewentry: *mut u32,
        lppeidnewentry: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn DoConfigPropsheet(
        &self,
        uluiparam: usize,
        ulflags: u32,
        lpsztitle: *mut i8,
        lpdisplaytable: windows_core::Ref<'_, IMAPITable>,
        lpconfigdata: windows_core::Ref<'_, IMAPIProp>,
        ultoppage: u32,
    ) -> windows_core::Result<()>;
    fn CopyMessages(
        &self,
        lpsrcinterface: *mut windows_core::GUID,
        lpsrcfolder: *mut core::ffi::c_void,
        lpmsglist: *mut SBinaryArray,
        lpdestinterface: *mut windows_core::GUID,
        lpdestfolder: *mut core::ffi::c_void,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn CopyFolder(
        &self,
        lpsrcinterface: *mut windows_core::GUID,
        lpsrcfolder: *mut core::ffi::c_void,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpdestinterface: *mut windows_core::GUID,
        lpdestfolder: *mut core::ffi::c_void,
        lsznewfoldername: *mut i8,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn DoCopyTo(
        &self,
        lpsrcinterface: *mut windows_core::GUID,
        lpsrcobj: *mut core::ffi::c_void,
        ciidexclude: u32,
        rgiidexclude: *mut windows_core::GUID,
        lpexcludeprops: *mut SPropTagArray,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        lpdestinterface: *mut windows_core::GUID,
        lpdestobj: *mut core::ffi::c_void,
        ulflags: u32,
        lppproblems: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()>;
    fn DoCopyProps(
        &self,
        lpsrcinterface: *mut windows_core::GUID,
        lpsrcobj: *mut core::ffi::c_void,
        lpincludeprops: *mut SPropTagArray,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        lpdestinterface: *mut windows_core::GUID,
        lpdestobj: *mut core::ffi::c_void,
        ulflags: u32,
        lppproblems: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()>;
    fn DoProgressDialog(
        &self,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<IMAPIProgress>;
    fn ReadReceipt(
        &self,
        ulflags: u32,
        lpreadmessage: windows_core::Ref<'_, IMessage>,
    ) -> windows_core::Result<IMessage>;
    fn PrepareSubmit(
        &self,
        lpmessage: windows_core::Ref<'_, IMessage>,
        lpulflags: *mut u32,
    ) -> windows_core::Result<()>;
    fn ExpandRecips(
        &self,
        lpmessage: windows_core::Ref<'_, IMessage>,
        lpulflags: *mut u32,
    ) -> windows_core::Result<()>;
    fn UpdatePAB(
        &self,
        ulflags: u32,
        lpmessage: windows_core::Ref<'_, IMessage>,
    ) -> windows_core::Result<()>;
    fn DoSentMail(
        &self,
        ulflags: u32,
        lpmessage: windows_core::Ref<'_, IMessage>,
    ) -> windows_core::Result<()>;
    fn OpenAddressBook(
        &self,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppadrbook: windows_core::OutRef<'_, IAddrBook>,
    ) -> windows_core::Result<()>;
    fn Preprocess(
        &self,
        ulflags: u32,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn CompleteMsg(
        &self,
        ulflags: u32,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn StoreLogoffTransports(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
    fn StatusRecips(
        &self,
        lpmessage: windows_core::Ref<'_, IMessage>,
        lpreciplist: *mut ADRLIST,
    ) -> windows_core::Result<()>;
    fn WrapStoreEntryID(
        &self,
        cborigentry: u32,
        lporigentry: *mut ENTRYID,
        lpcbwrappedentry: *mut u32,
        lppwrappedentry: *mut *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn ModifyProfile(&self, ulflags: u32) -> windows_core::Result<()>;
    fn IStorageFromStream(
        &self,
        lpunkin: windows_core::Ref<'_, windows_core::IUnknown>,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppstorageout: windows_core::OutRef<
            '_,
            windows::Win32::System::Com::StructuredStorage::IStorage,
        >,
    ) -> windows_core::Result<()>;
    fn GetSvcConfigSupportObj(&self, ulflags: u32) -> windows_core::Result<IMAPISupport>;
}
impl IMAPISupport_Vtbl {
    pub const fn new<Identity: IMAPISupport_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMemAllocRoutines<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpallocatebuffer: *mut LPALLOCATEBUFFER,
            lpallocatemore: *mut LPALLOCATEMORE,
            lpfreebuffer: *mut LPFREEBUFFER,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::GetMemAllocRoutines(
                    this,
                    core::mem::transmute_copy(&lpallocatebuffer),
                    core::mem::transmute_copy(&lpallocatemore),
                    core::mem::transmute_copy(&lpfreebuffer),
                )
                .into()
            }
        }
        unsafe extern "system" fn Subscribe<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpkey: *mut NOTIFKEY,
            uleventmask: u32,
            ulflags: u32,
            lpadvisesink: *mut core::ffi::c_void,
            lpulconnection: *mut usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::Subscribe(
                    this,
                    core::mem::transmute_copy(&lpkey),
                    core::mem::transmute_copy(&uleventmask),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpadvisesink),
                    core::mem::transmute_copy(&lpulconnection),
                )
                .into()
            }
        }
        unsafe extern "system" fn Unsubscribe<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulconnection: usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::Unsubscribe(this, core::mem::transmute_copy(&ulconnection))
                    .into()
            }
        }
        unsafe extern "system" fn Notify<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpkey: *mut NOTIFKEY,
            cnotification: u32,
            lpnotifications: *mut NOTIFICATION,
            lpulflags: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::Notify(
                    this,
                    core::mem::transmute_copy(&lpkey),
                    core::mem::transmute_copy(&cnotification),
                    core::mem::transmute_copy(&lpnotifications),
                    core::mem::transmute_copy(&lpulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn ModifyStatusRow<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cvalues: u32,
            lpcolumnvals: *mut SPropValue,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::ModifyStatusRow(
                    this,
                    core::mem::transmute_copy(&cvalues),
                    core::mem::transmute_copy(&lpcolumnvals),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn OpenProfileSection<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            ulflags: u32,
            lppprofileobj: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::OpenProfileSection(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppprofileobj),
                )
                .into()
            }
        }
        unsafe extern "system" fn RegisterPreprocessor<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpmuid: *mut MAPIUID,
            lpszadrtype: *mut i8,
            lpszdllname: *mut i8,
            lpszpreprocess: windows_core::PCSTR,
            lpszremovepreprocessinfo: windows_core::PCSTR,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::RegisterPreprocessor(
                    this,
                    core::mem::transmute_copy(&lpmuid),
                    core::mem::transmute_copy(&lpszadrtype),
                    core::mem::transmute_copy(&lpszdllname),
                    core::mem::transmute(&lpszpreprocess),
                    core::mem::transmute(&lpszremovepreprocessinfo),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn NewUID<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpmuid: *mut MAPIUID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::NewUID(this, core::mem::transmute_copy(&lpmuid)).into()
            }
        }
        unsafe extern "system" fn MakeInvalid<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpobject: *mut core::ffi::c_void,
            ulrefcount: u32,
            cmethods: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::MakeInvalid(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpobject),
                    core::mem::transmute_copy(&ulrefcount),
                    core::mem::transmute_copy(&cmethods),
                )
                .into()
            }
        }
        unsafe extern "system" fn SpoolerYield<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::SpoolerYield(this, core::mem::transmute_copy(&ulflags)).into()
            }
        }
        unsafe extern "system" fn SpoolerNotify<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpvdata: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::SpoolerNotify(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpvdata),
                )
                .into()
            }
        }
        unsafe extern "system" fn CreateOneOff<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpszname: *mut i8,
            lpszadrtype: *mut i8,
            lpszaddress: *mut i8,
            ulflags: u32,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::CreateOneOff(
                    this,
                    core::mem::transmute_copy(&lpszname),
                    core::mem::transmute_copy(&lpszadrtype),
                    core::mem::transmute_copy(&lpszaddress),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetProviderUID<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpproviderid: *mut MAPIUID,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::SetProviderUID(
                    this,
                    core::mem::transmute_copy(&lpproviderid),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn CompareEntryIDs<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cbentry1: u32,
            lpentry1: *mut ENTRYID,
            cbentry2: u32,
            lpentry2: *mut ENTRYID,
            ulcompareflags: u32,
            lpulresult: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::CompareEntryIDs(
                    this,
                    core::mem::transmute_copy(&cbentry1),
                    core::mem::transmute_copy(&lpentry1),
                    core::mem::transmute_copy(&cbentry2),
                    core::mem::transmute_copy(&lpentry2),
                    core::mem::transmute_copy(&ulcompareflags),
                    core::mem::transmute_copy(&lpulresult),
                )
                .into()
            }
        }
        unsafe extern "system" fn OpenTemplateID<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cbtemplateid: u32,
            lptemplateid: *mut ENTRYID,
            ultemplateflags: u32,
            lpmapipropdata: *mut core::ffi::c_void,
            lpinterface: *mut windows_core::GUID,
            lppmapipropnew: *mut *mut core::ffi::c_void,
            lpmapipropsibling: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::OpenTemplateID(
                    this,
                    core::mem::transmute_copy(&cbtemplateid),
                    core::mem::transmute_copy(&lptemplateid),
                    core::mem::transmute_copy(&ultemplateflags),
                    core::mem::transmute_copy(&lpmapipropdata),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&lppmapipropnew),
                    core::mem::transmute_copy(&lpmapipropsibling),
                )
                .into()
            }
        }
        unsafe extern "system" fn OpenEntry<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpinterface: *mut windows_core::GUID,
            ulopenflags: u32,
            lpulobjtype: *mut u32,
            lppunk: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::OpenEntry(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulopenflags),
                    core::mem::transmute_copy(&lpulobjtype),
                    core::mem::transmute_copy(&lppunk),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetOneOffTable<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPISupport_Impl::GetOneOffTable(this, core::mem::transmute_copy(&ulflags)) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn Address<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpuluiparam: *mut usize,
            lpadrparms: *mut ADRPARM,
            lppadrlist: *mut *mut ADRLIST,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::Address(
                    this,
                    core::mem::transmute_copy(&lpuluiparam),
                    core::mem::transmute_copy(&lpadrparms),
                    core::mem::transmute_copy(&lppadrlist),
                )
                .into()
            }
        }
        unsafe extern "system" fn Details<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpuluiparam: *mut usize,
            lpfndismiss: LPFNDISMISS,
            lpvdismisscontext: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
            lpvbuttoncontext: *mut core::ffi::c_void,
            lpszbuttontext: *mut i8,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::Details(
                    this,
                    core::mem::transmute_copy(&lpuluiparam),
                    core::mem::transmute_copy(&lpfndismiss),
                    core::mem::transmute_copy(&lpvdismisscontext),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpfbuttoncallback),
                    core::mem::transmute_copy(&lpvbuttoncontext),
                    core::mem::transmute_copy(&lpszbuttontext),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn NewEntry<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            cbeidcontainer: u32,
            lpeidcontainer: *mut ENTRYID,
            cbeidnewentrytpl: u32,
            lpeidnewentrytpl: *mut ENTRYID,
            lpcbeidnewentry: *mut u32,
            lppeidnewentry: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::NewEntry(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&cbeidcontainer),
                    core::mem::transmute_copy(&lpeidcontainer),
                    core::mem::transmute_copy(&cbeidnewentrytpl),
                    core::mem::transmute_copy(&lpeidnewentrytpl),
                    core::mem::transmute_copy(&lpcbeidnewentry),
                    core::mem::transmute_copy(&lppeidnewentry),
                )
                .into()
            }
        }
        unsafe extern "system" fn DoConfigPropsheet<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            lpsztitle: *mut i8,
            lpdisplaytable: *mut core::ffi::c_void,
            lpconfigdata: *mut core::ffi::c_void,
            ultoppage: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::DoConfigPropsheet(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpsztitle),
                    core::mem::transmute_copy(&lpdisplaytable),
                    core::mem::transmute_copy(&lpconfigdata),
                    core::mem::transmute_copy(&ultoppage),
                )
                .into()
            }
        }
        unsafe extern "system" fn CopyMessages<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpsrcinterface: *mut windows_core::GUID,
            lpsrcfolder: *mut core::ffi::c_void,
            lpmsglist: *mut SBinaryArray,
            lpdestinterface: *mut windows_core::GUID,
            lpdestfolder: *mut core::ffi::c_void,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::CopyMessages(
                    this,
                    core::mem::transmute_copy(&lpsrcinterface),
                    core::mem::transmute_copy(&lpsrcfolder),
                    core::mem::transmute_copy(&lpmsglist),
                    core::mem::transmute_copy(&lpdestinterface),
                    core::mem::transmute_copy(&lpdestfolder),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn CopyFolder<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpsrcinterface: *mut windows_core::GUID,
            lpsrcfolder: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpdestinterface: *mut windows_core::GUID,
            lpdestfolder: *mut core::ffi::c_void,
            lsznewfoldername: *mut i8,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::CopyFolder(
                    this,
                    core::mem::transmute_copy(&lpsrcinterface),
                    core::mem::transmute_copy(&lpsrcfolder),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpdestinterface),
                    core::mem::transmute_copy(&lpdestfolder),
                    core::mem::transmute_copy(&lsznewfoldername),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn DoCopyTo<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpsrcinterface: *mut windows_core::GUID,
            lpsrcobj: *mut core::ffi::c_void,
            ciidexclude: u32,
            rgiidexclude: *mut windows_core::GUID,
            lpexcludeprops: *mut SPropTagArray,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            lpdestinterface: *mut windows_core::GUID,
            lpdestobj: *mut core::ffi::c_void,
            ulflags: u32,
            lppproblems: *mut *mut SPropProblemArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::DoCopyTo(
                    this,
                    core::mem::transmute_copy(&lpsrcinterface),
                    core::mem::transmute_copy(&lpsrcobj),
                    core::mem::transmute_copy(&ciidexclude),
                    core::mem::transmute_copy(&rgiidexclude),
                    core::mem::transmute_copy(&lpexcludeprops),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&lpdestinterface),
                    core::mem::transmute_copy(&lpdestobj),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppproblems),
                )
                .into()
            }
        }
        unsafe extern "system" fn DoCopyProps<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpsrcinterface: *mut windows_core::GUID,
            lpsrcobj: *mut core::ffi::c_void,
            lpincludeprops: *mut SPropTagArray,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            lpdestinterface: *mut windows_core::GUID,
            lpdestobj: *mut core::ffi::c_void,
            ulflags: u32,
            lppproblems: *mut *mut SPropProblemArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::DoCopyProps(
                    this,
                    core::mem::transmute_copy(&lpsrcinterface),
                    core::mem::transmute_copy(&lpsrcobj),
                    core::mem::transmute_copy(&lpincludeprops),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&lpdestinterface),
                    core::mem::transmute_copy(&lpdestobj),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppproblems),
                )
                .into()
            }
        }
        unsafe extern "system" fn DoProgressDialog<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
            lppprogress: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPISupport_Impl::DoProgressDialog(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        lppprogress.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn ReadReceipt<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpreadmessage: *mut core::ffi::c_void,
            lppemptymessage: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPISupport_Impl::ReadReceipt(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpreadmessage),
                ) {
                    Ok(ok__) => {
                        lppemptymessage.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn PrepareSubmit<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpmessage: *mut core::ffi::c_void,
            lpulflags: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::PrepareSubmit(
                    this,
                    core::mem::transmute_copy(&lpmessage),
                    core::mem::transmute_copy(&lpulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn ExpandRecips<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpmessage: *mut core::ffi::c_void,
            lpulflags: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::ExpandRecips(
                    this,
                    core::mem::transmute_copy(&lpmessage),
                    core::mem::transmute_copy(&lpulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn UpdatePAB<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpmessage: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::UpdatePAB(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpmessage),
                )
                .into()
            }
        }
        unsafe extern "system" fn DoSentMail<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpmessage: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::DoSentMail(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpmessage),
                )
                .into()
            }
        }
        unsafe extern "system" fn OpenAddressBook<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lppadrbook: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::OpenAddressBook(
                    this,
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppadrbook),
                )
                .into()
            }
        }
        unsafe extern "system" fn Preprocess<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::Preprocess(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn CompleteMsg<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::CompleteMsg(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn StoreLogoffTransports<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpulflags: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::StoreLogoffTransports(
                    this,
                    core::mem::transmute_copy(&lpulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn StatusRecips<Identity: IMAPISupport_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpmessage: *mut core::ffi::c_void,
            lpreciplist: *mut ADRLIST,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::StatusRecips(
                    this,
                    core::mem::transmute_copy(&lpmessage),
                    core::mem::transmute_copy(&lpreciplist),
                )
                .into()
            }
        }
        unsafe extern "system" fn WrapStoreEntryID<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cborigentry: u32,
            lporigentry: *mut ENTRYID,
            lpcbwrappedentry: *mut u32,
            lppwrappedentry: *mut *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::WrapStoreEntryID(
                    this,
                    core::mem::transmute_copy(&cborigentry),
                    core::mem::transmute_copy(&lporigentry),
                    core::mem::transmute_copy(&lpcbwrappedentry),
                    core::mem::transmute_copy(&lppwrappedentry),
                )
                .into()
            }
        }
        unsafe extern "system" fn ModifyProfile<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::ModifyProfile(this, core::mem::transmute_copy(&ulflags)).into()
            }
        }
        unsafe extern "system" fn IStorageFromStream<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpunkin: *mut core::ffi::c_void,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lppstorageout: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPISupport_Impl::IStorageFromStream(
                    this,
                    core::mem::transmute_copy(&lpunkin),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppstorageout),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetSvcConfigSupportObj<
            Identity: IMAPISupport_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lppsvcsupport: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMAPISupport_Impl::GetSvcConfigSupportObj(
                    this,
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        lppsvcsupport.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            GetMemAllocRoutines: GetMemAllocRoutines::<Identity, OFFSET>,
            Subscribe: Subscribe::<Identity, OFFSET>,
            Unsubscribe: Unsubscribe::<Identity, OFFSET>,
            Notify: Notify::<Identity, OFFSET>,
            ModifyStatusRow: ModifyStatusRow::<Identity, OFFSET>,
            OpenProfileSection: OpenProfileSection::<Identity, OFFSET>,
            RegisterPreprocessor: RegisterPreprocessor::<Identity, OFFSET>,
            NewUID: NewUID::<Identity, OFFSET>,
            MakeInvalid: MakeInvalid::<Identity, OFFSET>,
            SpoolerYield: SpoolerYield::<Identity, OFFSET>,
            SpoolerNotify: SpoolerNotify::<Identity, OFFSET>,
            CreateOneOff: CreateOneOff::<Identity, OFFSET>,
            SetProviderUID: SetProviderUID::<Identity, OFFSET>,
            CompareEntryIDs: CompareEntryIDs::<Identity, OFFSET>,
            OpenTemplateID: OpenTemplateID::<Identity, OFFSET>,
            OpenEntry: OpenEntry::<Identity, OFFSET>,
            GetOneOffTable: GetOneOffTable::<Identity, OFFSET>,
            Address: Address::<Identity, OFFSET>,
            Details: Details::<Identity, OFFSET>,
            NewEntry: NewEntry::<Identity, OFFSET>,
            DoConfigPropsheet: DoConfigPropsheet::<Identity, OFFSET>,
            CopyMessages: CopyMessages::<Identity, OFFSET>,
            CopyFolder: CopyFolder::<Identity, OFFSET>,
            DoCopyTo: DoCopyTo::<Identity, OFFSET>,
            DoCopyProps: DoCopyProps::<Identity, OFFSET>,
            DoProgressDialog: DoProgressDialog::<Identity, OFFSET>,
            ReadReceipt: ReadReceipt::<Identity, OFFSET>,
            PrepareSubmit: PrepareSubmit::<Identity, OFFSET>,
            ExpandRecips: ExpandRecips::<Identity, OFFSET>,
            UpdatePAB: UpdatePAB::<Identity, OFFSET>,
            DoSentMail: DoSentMail::<Identity, OFFSET>,
            OpenAddressBook: OpenAddressBook::<Identity, OFFSET>,
            Preprocess: Preprocess::<Identity, OFFSET>,
            CompleteMsg: CompleteMsg::<Identity, OFFSET>,
            StoreLogoffTransports: StoreLogoffTransports::<Identity, OFFSET>,
            StatusRecips: StatusRecips::<Identity, OFFSET>,
            WrapStoreEntryID: WrapStoreEntryID::<Identity, OFFSET>,
            ModifyProfile: ModifyProfile::<Identity, OFFSET>,
            IStorageFromStream: IStorageFromStream::<Identity, OFFSET>,
            GetSvcConfigSupportObj: GetSvcConfigSupportObj::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPISupport as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPISupport {}
windows_core::imp::define_interface!(
    IMAPITable,
    IMAPITable_Vtbl,
    0x00020301_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPITable, windows_core::IUnknown);
impl IMAPITable {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn Advise<P1>(
        &self,
        uleventmask: u32,
        lpadvisesink: P1,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<IMAPIAdviseSink>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Advise)(
                windows_core::Interface::as_raw(self),
                uleventmask,
                lpadvisesink.param().abi(),
                lpulconnection as _,
            )
            .ok()
        }
    }
    pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Unadvise)(
                windows_core::Interface::as_raw(self),
                ulconnection,
            )
            .ok()
        }
    }
    pub unsafe fn GetStatus(
        &self,
        lpultablestatus: *mut u32,
        lpultabletype: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetStatus)(
                windows_core::Interface::as_raw(self),
                lpultablestatus as _,
                lpultabletype as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetColumns(
        &self,
        lpproptagarray: *mut SPropTagArray,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetColumns)(
                windows_core::Interface::as_raw(self),
                lpproptagarray as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn QueryColumns(
        &self,
        ulflags: u32,
        lpproptagarray: *mut *mut SPropTagArray,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).QueryColumns)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpproptagarray as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetRowCount(
        &self,
        ulflags: u32,
        lpulcount: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetRowCount)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpulcount as _,
            )
            .ok()
        }
    }
    pub unsafe fn SeekRow(
        &self,
        bkorigin: usize,
        lrowcount: i32,
        lplrowssought: *mut i32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SeekRow)(
                windows_core::Interface::as_raw(self),
                bkorigin,
                lrowcount,
                lplrowssought as _,
            )
            .ok()
        }
    }
    pub unsafe fn SeekRowApprox(
        &self,
        ulnumerator: u32,
        uldenominator: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SeekRowApprox)(
                windows_core::Interface::as_raw(self),
                ulnumerator,
                uldenominator,
            )
            .ok()
        }
    }
    pub unsafe fn QueryPosition(
        &self,
        lpulrow: *mut u32,
        lpulnumerator: *mut u32,
        lpuldenominator: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).QueryPosition)(
                windows_core::Interface::as_raw(self),
                lpulrow as _,
                lpulnumerator as _,
                lpuldenominator as _,
            )
            .ok()
        }
    }
    pub unsafe fn FindRow(
        &self,
        lprestriction: *mut SRestriction,
        bkorigin: usize,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FindRow)(
                windows_core::Interface::as_raw(self),
                lprestriction as _,
                bkorigin,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn Restrict(
        &self,
        lprestriction: *mut SRestriction,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Restrict)(
                windows_core::Interface::as_raw(self),
                lprestriction as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn CreateBookmark(&self, lpbkposition: *mut usize) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CreateBookmark)(
                windows_core::Interface::as_raw(self),
                lpbkposition as _,
            )
            .ok()
        }
    }
    pub unsafe fn FreeBookmark(&self, bkposition: usize) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FreeBookmark)(
                windows_core::Interface::as_raw(self),
                bkposition,
            )
            .ok()
        }
    }
    pub unsafe fn SortTable(
        &self,
        lpsortcriteria: *mut SSortOrderSet,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SortTable)(
                windows_core::Interface::as_raw(self),
                lpsortcriteria as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn QuerySortOrder(
        &self,
        lppsortcriteria: *mut *mut SSortOrderSet,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).QuerySortOrder)(
                windows_core::Interface::as_raw(self),
                lppsortcriteria as _,
            )
            .ok()
        }
    }
    pub unsafe fn QueryRows(
        &self,
        lrowcount: i32,
        ulflags: u32,
        lpprows: *mut *mut SRowSet,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).QueryRows)(
                windows_core::Interface::as_raw(self),
                lrowcount,
                ulflags,
                lpprows as _,
            )
            .ok()
        }
    }
    pub unsafe fn Abort(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Abort)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn ExpandRow(
        &self,
        cbinstancekey: u32,
        pbinstancekey: *mut u8,
        ulrowcount: u32,
        ulflags: u32,
        lpprows: *mut *mut SRowSet,
        lpulmorerows: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ExpandRow)(
                windows_core::Interface::as_raw(self),
                cbinstancekey,
                pbinstancekey as _,
                ulrowcount,
                ulflags,
                lpprows as _,
                lpulmorerows as _,
            )
            .ok()
        }
    }
    pub unsafe fn CollapseRow(
        &self,
        cbinstancekey: u32,
        pbinstancekey: *mut u8,
        ulflags: u32,
        lpulrowcount: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CollapseRow)(
                windows_core::Interface::as_raw(self),
                cbinstancekey,
                pbinstancekey as _,
                ulflags,
                lpulrowcount as _,
            )
            .ok()
        }
    }
    pub unsafe fn WaitForCompletion(
        &self,
        ulflags: u32,
        ultimeout: u32,
        lpultablestatus: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).WaitForCompletion)(
                windows_core::Interface::as_raw(self),
                ulflags,
                ultimeout,
                lpultablestatus as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetCollapseState(
        &self,
        ulflags: u32,
        cbinstancekey: u32,
        lpbinstancekey: *mut u8,
        lpcbcollapsestate: *mut u32,
        lppbcollapsestate: *mut *mut u8,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetCollapseState)(
                windows_core::Interface::as_raw(self),
                ulflags,
                cbinstancekey,
                lpbinstancekey as _,
                lpcbcollapsestate as _,
                lppbcollapsestate as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetCollapseState(
        &self,
        ulflags: u32,
        pbcollapsestate: &mut [u8],
        lpbklocation: *mut usize,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetCollapseState)(
                windows_core::Interface::as_raw(self),
                ulflags,
                pbcollapsestate.len().try_into().unwrap(),
                core::mem::transmute(pbcollapsestate.as_ptr()),
                lpbklocation as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPITable_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub Advise: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
        *mut usize,
    ) -> windows_core::HRESULT,
    pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
    pub GetStatus: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut u32,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub SetColumns: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SPropTagArray,
        u32,
    ) -> windows_core::HRESULT,
    pub QueryColumns: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut SPropTagArray,
    ) -> windows_core::HRESULT,
    pub GetRowCount:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut u32) -> windows_core::HRESULT,
    pub SeekRow: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        i32,
        *mut i32,
    ) -> windows_core::HRESULT,
    pub SeekRowApprox:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32) -> windows_core::HRESULT,
    pub QueryPosition: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut u32,
        *mut u32,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub FindRow: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SRestriction,
        usize,
        u32,
    ) -> windows_core::HRESULT,
    pub Restrict: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SRestriction,
        u32,
    ) -> windows_core::HRESULT,
    pub CreateBookmark:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut usize) -> windows_core::HRESULT,
    pub FreeBookmark:
        unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
    pub SortTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SSortOrderSet,
        u32,
    ) -> windows_core::HRESULT,
    pub QuerySortOrder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut SSortOrderSet,
    ) -> windows_core::HRESULT,
    pub QueryRows: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        i32,
        u32,
        *mut *mut SRowSet,
    ) -> windows_core::HRESULT,
    pub Abort: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub ExpandRow: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut u8,
        u32,
        u32,
        *mut *mut SRowSet,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub CollapseRow: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut u8,
        u32,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub WaitForCompletion: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub GetCollapseState: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut u8,
        *mut u32,
        *mut *mut u8,
    ) -> windows_core::HRESULT,
    pub SetCollapseState: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut u8,
        *mut usize,
    ) -> windows_core::HRESULT,
}
pub trait IMAPITable_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn Advise(
        &self,
        uleventmask: u32,
        lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>;
    fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
    fn GetStatus(
        &self,
        lpultablestatus: *mut u32,
        lpultabletype: *mut u32,
    ) -> windows_core::Result<()>;
    fn SetColumns(
        &self,
        lpproptagarray: *mut SPropTagArray,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn QueryColumns(
        &self,
        ulflags: u32,
        lpproptagarray: *mut *mut SPropTagArray,
    ) -> windows_core::Result<()>;
    fn GetRowCount(&self, ulflags: u32, lpulcount: *mut u32) -> windows_core::Result<()>;
    fn SeekRow(
        &self,
        bkorigin: usize,
        lrowcount: i32,
        lplrowssought: *mut i32,
    ) -> windows_core::Result<()>;
    fn SeekRowApprox(&self, ulnumerator: u32, uldenominator: u32) -> windows_core::Result<()>;
    fn QueryPosition(
        &self,
        lpulrow: *mut u32,
        lpulnumerator: *mut u32,
        lpuldenominator: *mut u32,
    ) -> windows_core::Result<()>;
    fn FindRow(
        &self,
        lprestriction: *mut SRestriction,
        bkorigin: usize,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn Restrict(&self, lprestriction: *mut SRestriction, ulflags: u32) -> windows_core::Result<()>;
    fn CreateBookmark(&self, lpbkposition: *mut usize) -> windows_core::Result<()>;
    fn FreeBookmark(&self, bkposition: usize) -> windows_core::Result<()>;
    fn SortTable(
        &self,
        lpsortcriteria: *mut SSortOrderSet,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn QuerySortOrder(&self, lppsortcriteria: *mut *mut SSortOrderSet) -> windows_core::Result<()>;
    fn QueryRows(
        &self,
        lrowcount: i32,
        ulflags: u32,
        lpprows: *mut *mut SRowSet,
    ) -> windows_core::Result<()>;
    fn Abort(&self) -> windows_core::Result<()>;
    fn ExpandRow(
        &self,
        cbinstancekey: u32,
        pbinstancekey: *mut u8,
        ulrowcount: u32,
        ulflags: u32,
        lpprows: *mut *mut SRowSet,
        lpulmorerows: *mut u32,
    ) -> windows_core::Result<()>;
    fn CollapseRow(
        &self,
        cbinstancekey: u32,
        pbinstancekey: *mut u8,
        ulflags: u32,
        lpulrowcount: *mut u32,
    ) -> windows_core::Result<()>;
    fn WaitForCompletion(
        &self,
        ulflags: u32,
        ultimeout: u32,
        lpultablestatus: *mut u32,
    ) -> windows_core::Result<()>;
    fn GetCollapseState(
        &self,
        ulflags: u32,
        cbinstancekey: u32,
        lpbinstancekey: *mut u8,
        lpcbcollapsestate: *mut u32,
        lppbcollapsestate: *mut *mut u8,
    ) -> windows_core::Result<()>;
    fn SetCollapseState(
        &self,
        ulflags: u32,
        cbcollapsestate: u32,
        pbcollapsestate: *mut u8,
        lpbklocation: *mut usize,
    ) -> windows_core::Result<()>;
}
impl IMAPITable_Vtbl {
    pub const fn new<Identity: IMAPITable_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn Advise<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uleventmask: u32,
            lpadvisesink: *mut core::ffi::c_void,
            lpulconnection: *mut usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::Advise(
                    this,
                    core::mem::transmute_copy(&uleventmask),
                    core::mem::transmute_copy(&lpadvisesink),
                    core::mem::transmute_copy(&lpulconnection),
                )
                .into()
            }
        }
        unsafe extern "system" fn Unadvise<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulconnection: usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
            }
        }
        unsafe extern "system" fn GetStatus<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpultablestatus: *mut u32,
            lpultabletype: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::GetStatus(
                    this,
                    core::mem::transmute_copy(&lpultablestatus),
                    core::mem::transmute_copy(&lpultabletype),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetColumns<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpproptagarray: *mut SPropTagArray,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::SetColumns(
                    this,
                    core::mem::transmute_copy(&lpproptagarray),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn QueryColumns<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpproptagarray: *mut *mut SPropTagArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::QueryColumns(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpproptagarray),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetRowCount<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpulcount: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::GetRowCount(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulcount),
                )
                .into()
            }
        }
        unsafe extern "system" fn SeekRow<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            bkorigin: usize,
            lrowcount: i32,
            lplrowssought: *mut i32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::SeekRow(
                    this,
                    core::mem::transmute_copy(&bkorigin),
                    core::mem::transmute_copy(&lrowcount),
                    core::mem::transmute_copy(&lplrowssought),
                )
                .into()
            }
        }
        unsafe extern "system" fn SeekRowApprox<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulnumerator: u32,
            uldenominator: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::SeekRowApprox(
                    this,
                    core::mem::transmute_copy(&ulnumerator),
                    core::mem::transmute_copy(&uldenominator),
                )
                .into()
            }
        }
        unsafe extern "system" fn QueryPosition<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulrow: *mut u32,
            lpulnumerator: *mut u32,
            lpuldenominator: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::QueryPosition(
                    this,
                    core::mem::transmute_copy(&lpulrow),
                    core::mem::transmute_copy(&lpulnumerator),
                    core::mem::transmute_copy(&lpuldenominator),
                )
                .into()
            }
        }
        unsafe extern "system" fn FindRow<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lprestriction: *mut SRestriction,
            bkorigin: usize,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::FindRow(
                    this,
                    core::mem::transmute_copy(&lprestriction),
                    core::mem::transmute_copy(&bkorigin),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn Restrict<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lprestriction: *mut SRestriction,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::Restrict(
                    this,
                    core::mem::transmute_copy(&lprestriction),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn CreateBookmark<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpbkposition: *mut usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::CreateBookmark(this, core::mem::transmute_copy(&lpbkposition))
                    .into()
            }
        }
        unsafe extern "system" fn FreeBookmark<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            bkposition: usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::FreeBookmark(this, core::mem::transmute_copy(&bkposition)).into()
            }
        }
        unsafe extern "system" fn SortTable<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpsortcriteria: *mut SSortOrderSet,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::SortTable(
                    this,
                    core::mem::transmute_copy(&lpsortcriteria),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn QuerySortOrder<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lppsortcriteria: *mut *mut SSortOrderSet,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::QuerySortOrder(this, core::mem::transmute_copy(&lppsortcriteria))
                    .into()
            }
        }
        unsafe extern "system" fn QueryRows<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lrowcount: i32,
            ulflags: u32,
            lpprows: *mut *mut SRowSet,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::QueryRows(
                    this,
                    core::mem::transmute_copy(&lrowcount),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpprows),
                )
                .into()
            }
        }
        unsafe extern "system" fn Abort<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::Abort(this).into()
            }
        }
        unsafe extern "system" fn ExpandRow<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbinstancekey: u32,
            pbinstancekey: *mut u8,
            ulrowcount: u32,
            ulflags: u32,
            lpprows: *mut *mut SRowSet,
            lpulmorerows: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::ExpandRow(
                    this,
                    core::mem::transmute_copy(&cbinstancekey),
                    core::mem::transmute_copy(&pbinstancekey),
                    core::mem::transmute_copy(&ulrowcount),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpprows),
                    core::mem::transmute_copy(&lpulmorerows),
                )
                .into()
            }
        }
        unsafe extern "system" fn CollapseRow<Identity: IMAPITable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbinstancekey: u32,
            pbinstancekey: *mut u8,
            ulflags: u32,
            lpulrowcount: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::CollapseRow(
                    this,
                    core::mem::transmute_copy(&cbinstancekey),
                    core::mem::transmute_copy(&pbinstancekey),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulrowcount),
                )
                .into()
            }
        }
        unsafe extern "system" fn WaitForCompletion<
            Identity: IMAPITable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            ultimeout: u32,
            lpultablestatus: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::WaitForCompletion(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&ultimeout),
                    core::mem::transmute_copy(&lpultablestatus),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetCollapseState<
            Identity: IMAPITable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            cbinstancekey: u32,
            lpbinstancekey: *mut u8,
            lpcbcollapsestate: *mut u32,
            lppbcollapsestate: *mut *mut u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::GetCollapseState(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&cbinstancekey),
                    core::mem::transmute_copy(&lpbinstancekey),
                    core::mem::transmute_copy(&lpcbcollapsestate),
                    core::mem::transmute_copy(&lppbcollapsestate),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetCollapseState<
            Identity: IMAPITable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            cbcollapsestate: u32,
            pbcollapsestate: *mut u8,
            lpbklocation: *mut usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPITable_Impl::SetCollapseState(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&cbcollapsestate),
                    core::mem::transmute_copy(&pbcollapsestate),
                    core::mem::transmute_copy(&lpbklocation),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            Advise: Advise::<Identity, OFFSET>,
            Unadvise: Unadvise::<Identity, OFFSET>,
            GetStatus: GetStatus::<Identity, OFFSET>,
            SetColumns: SetColumns::<Identity, OFFSET>,
            QueryColumns: QueryColumns::<Identity, OFFSET>,
            GetRowCount: GetRowCount::<Identity, OFFSET>,
            SeekRow: SeekRow::<Identity, OFFSET>,
            SeekRowApprox: SeekRowApprox::<Identity, OFFSET>,
            QueryPosition: QueryPosition::<Identity, OFFSET>,
            FindRow: FindRow::<Identity, OFFSET>,
            Restrict: Restrict::<Identity, OFFSET>,
            CreateBookmark: CreateBookmark::<Identity, OFFSET>,
            FreeBookmark: FreeBookmark::<Identity, OFFSET>,
            SortTable: SortTable::<Identity, OFFSET>,
            QuerySortOrder: QuerySortOrder::<Identity, OFFSET>,
            QueryRows: QueryRows::<Identity, OFFSET>,
            Abort: Abort::<Identity, OFFSET>,
            ExpandRow: ExpandRow::<Identity, OFFSET>,
            CollapseRow: CollapseRow::<Identity, OFFSET>,
            WaitForCompletion: WaitForCompletion::<Identity, OFFSET>,
            GetCollapseState: GetCollapseState::<Identity, OFFSET>,
            SetCollapseState: SetCollapseState::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPITable as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPITable {}
pub const IMAPITable_Abort: METHODS = METHODS(31i32);
pub const IMAPITable_Advise: METHODS = METHODS(15i32);
pub const IMAPITable_CollapseRow: METHODS = METHODS(33i32);
pub const IMAPITable_CreateBookmark: METHODS = METHODS(26i32);
pub const IMAPITable_ExpandRow: METHODS = METHODS(32i32);
pub const IMAPITable_FindRow: METHODS = METHODS(24i32);
pub const IMAPITable_FreeBookmark: METHODS = METHODS(27i32);
pub const IMAPITable_GetCollapseState: METHODS = METHODS(35i32);
pub const IMAPITable_GetLastError: METHODS = METHODS(14i32);
pub const IMAPITable_GetRowCount: METHODS = METHODS(20i32);
pub const IMAPITable_GetStatus: METHODS = METHODS(17i32);
pub const IMAPITable_QueryColumns: METHODS = METHODS(19i32);
pub const IMAPITable_QueryPosition: METHODS = METHODS(23i32);
pub const IMAPITable_QueryRows: METHODS = METHODS(30i32);
pub const IMAPITable_QuerySortOrder: METHODS = METHODS(29i32);
pub const IMAPITable_Restrict: METHODS = METHODS(25i32);
pub const IMAPITable_SeekRow: METHODS = METHODS(21i32);
pub const IMAPITable_SeekRowApprox: METHODS = METHODS(22i32);
pub const IMAPITable_SetCollapseState: METHODS = METHODS(36i32);
pub const IMAPITable_SetColumns: METHODS = METHODS(18i32);
pub const IMAPITable_SortTable: METHODS = METHODS(28i32);
pub const IMAPITable_Unadvise: METHODS = METHODS(16i32);
pub const IMAPITable_WaitForCompletion: METHODS = METHODS(34i32);
windows_core::imp::define_interface!(
    IMAPIViewAdviseSink,
    IMAPIViewAdviseSink_Vtbl,
    0x0002032b_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIViewAdviseSink, windows_core::IUnknown);
impl IMAPIViewAdviseSink {
    pub unsafe fn OnShutdown(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OnShutdown)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn OnNewMessage(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OnNewMessage)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn OnPrint(
        &self,
        dwpagenumber: u32,
        hrstatus: windows_core::HRESULT,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OnPrint)(
                windows_core::Interface::as_raw(self),
                dwpagenumber,
                hrstatus,
            )
            .ok()
        }
    }
    pub unsafe fn OnSubmitted(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OnSubmitted)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn OnSaved(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OnSaved)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIViewAdviseSink_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub OnShutdown: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub OnNewMessage: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub OnPrint: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        windows_core::HRESULT,
    ) -> windows_core::HRESULT,
    pub OnSubmitted: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub OnSaved: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IMAPIViewAdviseSink_Impl: windows_core::IUnknownImpl {
    fn OnShutdown(&self) -> windows_core::Result<()>;
    fn OnNewMessage(&self) -> windows_core::Result<()>;
    fn OnPrint(
        &self,
        dwpagenumber: u32,
        hrstatus: windows_core::HRESULT,
    ) -> windows_core::Result<()>;
    fn OnSubmitted(&self) -> windows_core::Result<()>;
    fn OnSaved(&self) -> windows_core::Result<()>;
}
impl IMAPIViewAdviseSink_Vtbl {
    pub const fn new<Identity: IMAPIViewAdviseSink_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn OnShutdown<
            Identity: IMAPIViewAdviseSink_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIViewAdviseSink_Impl::OnShutdown(this).into()
            }
        }
        unsafe extern "system" fn OnNewMessage<
            Identity: IMAPIViewAdviseSink_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIViewAdviseSink_Impl::OnNewMessage(this).into()
            }
        }
        unsafe extern "system" fn OnPrint<
            Identity: IMAPIViewAdviseSink_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwpagenumber: u32,
            hrstatus: windows_core::HRESULT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIViewAdviseSink_Impl::OnPrint(
                    this,
                    core::mem::transmute_copy(&dwpagenumber),
                    core::mem::transmute_copy(&hrstatus),
                )
                .into()
            }
        }
        unsafe extern "system" fn OnSubmitted<
            Identity: IMAPIViewAdviseSink_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIViewAdviseSink_Impl::OnSubmitted(this).into()
            }
        }
        unsafe extern "system" fn OnSaved<
            Identity: IMAPIViewAdviseSink_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIViewAdviseSink_Impl::OnSaved(this).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            OnShutdown: OnShutdown::<Identity, OFFSET>,
            OnNewMessage: OnNewMessage::<Identity, OFFSET>,
            OnPrint: OnPrint::<Identity, OFFSET>,
            OnSubmitted: OnSubmitted::<Identity, OFFSET>,
            OnSaved: OnSaved::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIViewAdviseSink as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIViewAdviseSink {}
windows_core::imp::define_interface!(
    IMAPIViewContext,
    IMAPIViewContext_Vtbl,
    0x00020321_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIViewContext, windows_core::IUnknown);
impl IMAPIViewContext {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetAdviseSink<P0>(&self, pmvns: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMAPIFormAdviseSink>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SetAdviseSink)(
                windows_core::Interface::as_raw(self),
                pmvns.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn ActivateNext(
        &self,
        uldir: u32,
        prcposrect: *mut windows::Win32::Foundation::RECT,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ActivateNext)(
                windows_core::Interface::as_raw(self),
                uldir,
                prcposrect as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetPrintSetup(
        &self,
        ulflags: u32,
        lppformprintsetup: *mut *mut FORMPRINTSETUP,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetPrintSetup)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lppformprintsetup as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetSaveStream(
        &self,
        pulflags: *mut u32,
        pulformat: *mut u32,
        ppstm: *mut Option<windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetSaveStream)(
                windows_core::Interface::as_raw(self),
                pulflags as _,
                pulformat as _,
                core::mem::transmute(ppstm),
            )
            .ok()
        }
    }
    pub unsafe fn GetViewStatus(&self, lpulstatus: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetViewStatus)(
                windows_core::Interface::as_raw(self),
                lpulstatus as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMAPIViewContext_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub SetAdviseSink: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ActivateNext: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut windows::Win32::Foundation::RECT,
    ) -> windows_core::HRESULT,
    pub GetPrintSetup: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut FORMPRINTSETUP,
    ) -> windows_core::HRESULT,
    pub GetSaveStream: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut u32,
        *mut u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetViewStatus:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMAPIViewContext_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn SetAdviseSink(
        &self,
        pmvns: windows_core::Ref<'_, IMAPIFormAdviseSink>,
    ) -> windows_core::Result<()>;
    fn ActivateNext(
        &self,
        uldir: u32,
        prcposrect: *mut windows::Win32::Foundation::RECT,
    ) -> windows_core::Result<()>;
    fn GetPrintSetup(
        &self,
        ulflags: u32,
        lppformprintsetup: *mut *mut FORMPRINTSETUP,
    ) -> windows_core::Result<()>;
    fn GetSaveStream(
        &self,
        pulflags: *mut u32,
        pulformat: *mut u32,
        ppstm: windows_core::OutRef<'_, windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()>;
    fn GetViewStatus(&self, lpulstatus: *mut u32) -> windows_core::Result<()>;
}
impl IMAPIViewContext_Vtbl {
    pub const fn new<Identity: IMAPIViewContext_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IMAPIViewContext_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIViewContext_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetAdviseSink<
            Identity: IMAPIViewContext_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pmvns: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIViewContext_Impl::SetAdviseSink(this, core::mem::transmute_copy(&pmvns)).into()
            }
        }
        unsafe extern "system" fn ActivateNext<
            Identity: IMAPIViewContext_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            uldir: u32,
            prcposrect: *mut windows::Win32::Foundation::RECT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIViewContext_Impl::ActivateNext(
                    this,
                    core::mem::transmute_copy(&uldir),
                    core::mem::transmute_copy(&prcposrect),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetPrintSetup<
            Identity: IMAPIViewContext_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lppformprintsetup: *mut *mut FORMPRINTSETUP,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIViewContext_Impl::GetPrintSetup(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppformprintsetup),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetSaveStream<
            Identity: IMAPIViewContext_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pulflags: *mut u32,
            pulformat: *mut u32,
            ppstm: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIViewContext_Impl::GetSaveStream(
                    this,
                    core::mem::transmute_copy(&pulflags),
                    core::mem::transmute_copy(&pulformat),
                    core::mem::transmute_copy(&ppstm),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetViewStatus<
            Identity: IMAPIViewContext_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpulstatus: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMAPIViewContext_Impl::GetViewStatus(this, core::mem::transmute_copy(&lpulstatus))
                    .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            SetAdviseSink: SetAdviseSink::<Identity, OFFSET>,
            ActivateNext: ActivateNext::<Identity, OFFSET>,
            GetPrintSetup: GetPrintSetup::<Identity, OFFSET>,
            GetSaveStream: GetSaveStream::<Identity, OFFSET>,
            GetViewStatus: GetViewStatus::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMAPIViewContext as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMAPIViewContext {}
pub const IMF_ATTACHMENTS: IMSGFLAGS = IMSGFLAGS(1i32);
pub const IMF_CSETTAGGED: IMSGFLAGS = IMSGFLAGS(8192i32);
pub const IMF_ENCRYPTED: IMSGFLAGS = IMSGFLAGS(256i32);
pub const IMF_HASVCARD: IMSGFLAGS = IMSGFLAGS(65536i32);
pub const IMF_HTML: IMSGFLAGS = IMSGFLAGS(16i32);
pub const IMF_MHTML: IMSGFLAGS = IMSGFLAGS(1024i32);
pub const IMF_MIME: IMSGFLAGS = IMSGFLAGS(8i32);
pub const IMF_MULTIPART: IMSGFLAGS = IMSGFLAGS(2i32);
pub const IMF_NEWS: IMSGFLAGS = IMSGFLAGS(16384i32);
pub const IMF_PARTIAL: IMSGFLAGS = IMSGFLAGS(64i32);
pub const IMF_PLAIN: IMSGFLAGS = IMSGFLAGS(32i32);
pub const IMF_RFC1154: IMSGFLAGS = IMSGFLAGS(131072i32);
pub const IMF_SECURE: IMSGFLAGS = IMSGFLAGS(2048i32);
pub const IMF_SIGNED: IMSGFLAGS = IMSGFLAGS(128i32);
pub const IMF_SUBMULTIPART: IMSGFLAGS = IMSGFLAGS(4i32);
pub const IMF_TEXT: IMSGFLAGS = IMSGFLAGS(4096i32);
pub const IMF_TNEF: IMSGFLAGS = IMSGFLAGS(512i32);
pub const IMF_VOICEMAIL: IMSGFLAGS = IMSGFLAGS(32768i32);
pub const IMPORTANCE_HIGH: u32 = 2u32;
pub const IMPORTANCE_LOW: u32 = 0u32;
pub const IMPORTANCE_NORMAL: u32 = 1u32;
windows_core::imp::define_interface!(
    IMSCapabilities,
    IMSCapabilities_Vtbl,
    0x00020393_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMSCapabilities, windows_core::IUnknown);
impl IMSCapabilities {
    pub unsafe fn GetCapabilities(&self, mscapselector: MSCAP_SELECTOR) -> u32 {
        unsafe {
            (windows_core::Interface::vtable(self).GetCapabilities)(
                windows_core::Interface::as_raw(self),
                mscapselector,
            )
        }
    }
}
#[repr(C)]
pub struct IMSCapabilities_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetCapabilities: unsafe extern "system" fn(*mut core::ffi::c_void, MSCAP_SELECTOR) -> u32,
}
pub trait IMSCapabilities_Impl: windows_core::IUnknownImpl {
    fn GetCapabilities(&self, mscapselector: MSCAP_SELECTOR) -> u32;
}
impl IMSCapabilities_Vtbl {
    pub const fn new<Identity: IMSCapabilities_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetCapabilities<
            Identity: IMSCapabilities_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            mscapselector: MSCAP_SELECTOR,
        ) -> u32 {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMSCapabilities_Impl::GetCapabilities(
                    this,
                    core::mem::transmute_copy(&mscapselector),
                )
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetCapabilities: GetCapabilities::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMSCapabilities as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMSCapabilities {}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct IMSGBODYTYPE(pub i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct IMSGFLAGS(pub i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct IMSGPRIORITY(pub i32);
pub const IMSG_NO_ISTG_COMMIT: u32 = 1u32;
pub const IMSG_PRI_HIGH: IMSGPRIORITY = IMSGPRIORITY(1i32);
pub const IMSG_PRI_LOW: IMSGPRIORITY = IMSGPRIORITY(5i32);
pub const IMSG_PRI_NORMAL: IMSGPRIORITY = IMSGPRIORITY(3i32);
windows_core::imp::define_interface!(
    IMSLogon,
    IMSLogon_Vtbl,
    0x00020313_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMSLogon, windows_core::IUnknown);
impl IMSLogon {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn Logoff(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Logoff)(
                windows_core::Interface::as_raw(self),
                lpulflags as _,
            )
            .ok()
        }
    }
    pub unsafe fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppunk: *mut Option<windows_core::IUnknown>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenEntry)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                lpinterface as _,
                ulflags,
                lpulobjtype as _,
                core::mem::transmute(lppunk),
            )
            .ok()
        }
    }
    pub unsafe fn CompareEntryIDs(
        &self,
        cbentryid1: u32,
        lpentryid1: *mut ENTRYID,
        cbentryid2: u32,
        lpentryid2: *mut ENTRYID,
        ulflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CompareEntryIDs)(
                windows_core::Interface::as_raw(self),
                cbentryid1,
                lpentryid1 as _,
                cbentryid2,
                lpentryid2 as _,
                ulflags,
                lpulresult as _,
            )
            .ok()
        }
    }
    pub unsafe fn Advise<P3>(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        uleventmask: u32,
        lpadvisesink: P3,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<IMAPIAdviseSink>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Advise)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                uleventmask,
                lpadvisesink.param().abi(),
                lpulconnection as _,
            )
            .ok()
        }
    }
    pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Unadvise)(
                windows_core::Interface::as_raw(self),
                ulconnection,
            )
            .ok()
        }
    }
    pub unsafe fn OpenStatusEntry(
        &self,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppentry: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenStatusEntry)(
                windows_core::Interface::as_raw(self),
                lpinterface as _,
                ulflags,
                lpulobjtype as _,
                lppentry as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMSLogon_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub Logoff:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub OpenEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        *mut windows_core::GUID,
        u32,
        *mut u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CompareEntryIDs: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut ENTRYID,
        u32,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub Advise: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut core::ffi::c_void,
        *mut usize,
    ) -> windows_core::HRESULT,
    pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
    pub OpenStatusEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        u32,
        *mut u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMSLogon_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn Logoff(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
    fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
    ) -> windows_core::Result<()>;
    fn CompareEntryIDs(
        &self,
        cbentryid1: u32,
        lpentryid1: *mut ENTRYID,
        cbentryid2: u32,
        lpentryid2: *mut ENTRYID,
        ulflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()>;
    fn Advise(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        uleventmask: u32,
        lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>;
    fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
    fn OpenStatusEntry(
        &self,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppentry: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()>;
}
impl IMSLogon_Vtbl {
    pub const fn new<Identity: IMSLogon_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<Identity: IMSLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMSLogon_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn Logoff<Identity: IMSLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulflags: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMSLogon_Impl::Logoff(this, core::mem::transmute_copy(&lpulflags)).into()
            }
        }
        unsafe extern "system" fn OpenEntry<Identity: IMSLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lpulobjtype: *mut u32,
            lppunk: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMSLogon_Impl::OpenEntry(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulobjtype),
                    core::mem::transmute_copy(&lppunk),
                )
                .into()
            }
        }
        unsafe extern "system" fn CompareEntryIDs<Identity: IMSLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid1: u32,
            lpentryid1: *mut ENTRYID,
            cbentryid2: u32,
            lpentryid2: *mut ENTRYID,
            ulflags: u32,
            lpulresult: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMSLogon_Impl::CompareEntryIDs(
                    this,
                    core::mem::transmute_copy(&cbentryid1),
                    core::mem::transmute_copy(&lpentryid1),
                    core::mem::transmute_copy(&cbentryid2),
                    core::mem::transmute_copy(&lpentryid2),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulresult),
                )
                .into()
            }
        }
        unsafe extern "system" fn Advise<Identity: IMSLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            uleventmask: u32,
            lpadvisesink: *mut core::ffi::c_void,
            lpulconnection: *mut usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMSLogon_Impl::Advise(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&uleventmask),
                    core::mem::transmute_copy(&lpadvisesink),
                    core::mem::transmute_copy(&lpulconnection),
                )
                .into()
            }
        }
        unsafe extern "system" fn Unadvise<Identity: IMSLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulconnection: usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMSLogon_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
            }
        }
        unsafe extern "system" fn OpenStatusEntry<Identity: IMSLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lpulobjtype: *mut u32,
            lppentry: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMSLogon_Impl::OpenStatusEntry(
                    this,
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulobjtype),
                    core::mem::transmute_copy(&lppentry),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            Logoff: Logoff::<Identity, OFFSET>,
            OpenEntry: OpenEntry::<Identity, OFFSET>,
            CompareEntryIDs: CompareEntryIDs::<Identity, OFFSET>,
            Advise: Advise::<Identity, OFFSET>,
            Unadvise: Unadvise::<Identity, OFFSET>,
            OpenStatusEntry: OpenStatusEntry::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMSLogon as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMSLogon {}
pub const IMSLogon_Advise: METHODS = METHODS(116i32);
pub const IMSLogon_CompareEntryIDs: METHODS = METHODS(115i32);
pub const IMSLogon_GetLastError: METHODS = METHODS(112i32);
pub const IMSLogon_Logoff: METHODS = METHODS(113i32);
pub const IMSLogon_OpenEntry: METHODS = METHODS(114i32);
pub const IMSLogon_OpenStatusEntry: METHODS = METHODS(118i32);
pub const IMSLogon_Unadvise: METHODS = METHODS(117i32);
windows_core::imp::define_interface!(
    IMSProvider,
    IMSProvider_Vtbl,
    0x00020310_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMSProvider, windows_core::IUnknown);
impl IMSProvider {
    pub unsafe fn Shutdown(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Shutdown)(
                windows_core::Interface::as_raw(self),
                lpulflags as _,
            )
            .ok()
        }
    }
    pub unsafe fn Logon<P0>(
        &self,
        lpmapisup: P0,
        uluiparam: usize,
        lpszprofilename: *mut i8,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulflags: u32,
        lpinterface: *mut windows_core::GUID,
        lpcbspoolsecurity: *mut u32,
        lppbspoolsecurity: *mut *mut u8,
        lppmapierror: *mut *mut MAPIERROR,
        lppmslogon: *mut Option<IMSLogon>,
        lppmdb: *mut Option<IMsgStore>,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMAPISupport>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Logon)(
                windows_core::Interface::as_raw(self),
                lpmapisup.param().abi(),
                uluiparam,
                lpszprofilename as _,
                cbentryid,
                lpentryid as _,
                ulflags,
                lpinterface as _,
                lpcbspoolsecurity as _,
                lppbspoolsecurity as _,
                lppmapierror as _,
                core::mem::transmute(lppmslogon),
                core::mem::transmute(lppmdb),
            )
            .ok()
        }
    }
    pub unsafe fn SpoolerLogon<P0>(
        &self,
        lpmapisup: P0,
        uluiparam: usize,
        lpszprofilename: *mut i8,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulflags: u32,
        lpinterface: *mut windows_core::GUID,
        cbspoolsecurity: u32,
        lpbspoolsecurity: *mut u8,
        lppmapierror: *mut *mut MAPIERROR,
        lppmslogon: *mut Option<IMSLogon>,
        lppmdb: *mut Option<IMsgStore>,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMAPISupport>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SpoolerLogon)(
                windows_core::Interface::as_raw(self),
                lpmapisup.param().abi(),
                uluiparam,
                lpszprofilename as _,
                cbentryid,
                lpentryid as _,
                ulflags,
                lpinterface as _,
                cbspoolsecurity,
                lpbspoolsecurity as _,
                lppmapierror as _,
                core::mem::transmute(lppmslogon),
                core::mem::transmute(lppmdb),
            )
            .ok()
        }
    }
    pub unsafe fn CompareStoreIDs(
        &self,
        cbentryid1: u32,
        lpentryid1: *mut ENTRYID,
        cbentryid2: u32,
        lpentryid2: *mut ENTRYID,
        ulflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CompareStoreIDs)(
                windows_core::Interface::as_raw(self),
                cbentryid1,
                lpentryid1 as _,
                cbentryid2,
                lpentryid2 as _,
                ulflags,
                lpulresult as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMSProvider_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Shutdown:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub Logon: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        usize,
        *mut i8,
        u32,
        *mut ENTRYID,
        u32,
        *mut windows_core::GUID,
        *mut u32,
        *mut *mut u8,
        *mut *mut MAPIERROR,
        *mut *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SpoolerLogon: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        usize,
        *mut i8,
        u32,
        *mut ENTRYID,
        u32,
        *mut windows_core::GUID,
        u32,
        *mut u8,
        *mut *mut MAPIERROR,
        *mut *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CompareStoreIDs: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut ENTRYID,
        u32,
        *mut u32,
    ) -> windows_core::HRESULT,
}
pub trait IMSProvider_Impl: windows_core::IUnknownImpl {
    fn Shutdown(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
    fn Logon(
        &self,
        lpmapisup: windows_core::Ref<'_, IMAPISupport>,
        uluiparam: usize,
        lpszprofilename: *mut i8,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulflags: u32,
        lpinterface: *mut windows_core::GUID,
        lpcbspoolsecurity: *mut u32,
        lppbspoolsecurity: *mut *mut u8,
        lppmapierror: *mut *mut MAPIERROR,
        lppmslogon: windows_core::OutRef<'_, IMSLogon>,
        lppmdb: windows_core::OutRef<'_, IMsgStore>,
    ) -> windows_core::Result<()>;
    fn SpoolerLogon(
        &self,
        lpmapisup: windows_core::Ref<'_, IMAPISupport>,
        uluiparam: usize,
        lpszprofilename: *mut i8,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulflags: u32,
        lpinterface: *mut windows_core::GUID,
        cbspoolsecurity: u32,
        lpbspoolsecurity: *mut u8,
        lppmapierror: *mut *mut MAPIERROR,
        lppmslogon: windows_core::OutRef<'_, IMSLogon>,
        lppmdb: windows_core::OutRef<'_, IMsgStore>,
    ) -> windows_core::Result<()>;
    fn CompareStoreIDs(
        &self,
        cbentryid1: u32,
        lpentryid1: *mut ENTRYID,
        cbentryid2: u32,
        lpentryid2: *mut ENTRYID,
        ulflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()>;
}
impl IMSProvider_Vtbl {
    pub const fn new<Identity: IMSProvider_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Shutdown<Identity: IMSProvider_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulflags: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMSProvider_Impl::Shutdown(this, core::mem::transmute_copy(&lpulflags)).into()
            }
        }
        unsafe extern "system" fn Logon<Identity: IMSProvider_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpmapisup: *mut core::ffi::c_void,
            uluiparam: usize,
            lpszprofilename: *mut i8,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            ulflags: u32,
            lpinterface: *mut windows_core::GUID,
            lpcbspoolsecurity: *mut u32,
            lppbspoolsecurity: *mut *mut u8,
            lppmapierror: *mut *mut MAPIERROR,
            lppmslogon: *mut *mut core::ffi::c_void,
            lppmdb: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMSProvider_Impl::Logon(
                    this,
                    core::mem::transmute_copy(&lpmapisup),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpszprofilename),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&lpcbspoolsecurity),
                    core::mem::transmute_copy(&lppbspoolsecurity),
                    core::mem::transmute_copy(&lppmapierror),
                    core::mem::transmute_copy(&lppmslogon),
                    core::mem::transmute_copy(&lppmdb),
                )
                .into()
            }
        }
        unsafe extern "system" fn SpoolerLogon<Identity: IMSProvider_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpmapisup: *mut core::ffi::c_void,
            uluiparam: usize,
            lpszprofilename: *mut i8,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            ulflags: u32,
            lpinterface: *mut windows_core::GUID,
            cbspoolsecurity: u32,
            lpbspoolsecurity: *mut u8,
            lppmapierror: *mut *mut MAPIERROR,
            lppmslogon: *mut *mut core::ffi::c_void,
            lppmdb: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMSProvider_Impl::SpoolerLogon(
                    this,
                    core::mem::transmute_copy(&lpmapisup),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpszprofilename),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&cbspoolsecurity),
                    core::mem::transmute_copy(&lpbspoolsecurity),
                    core::mem::transmute_copy(&lppmapierror),
                    core::mem::transmute_copy(&lppmslogon),
                    core::mem::transmute_copy(&lppmdb),
                )
                .into()
            }
        }
        unsafe extern "system" fn CompareStoreIDs<
            Identity: IMSProvider_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cbentryid1: u32,
            lpentryid1: *mut ENTRYID,
            cbentryid2: u32,
            lpentryid2: *mut ENTRYID,
            ulflags: u32,
            lpulresult: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMSProvider_Impl::CompareStoreIDs(
                    this,
                    core::mem::transmute_copy(&cbentryid1),
                    core::mem::transmute_copy(&lpentryid1),
                    core::mem::transmute_copy(&cbentryid2),
                    core::mem::transmute_copy(&lpentryid2),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulresult),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Shutdown: Shutdown::<Identity, OFFSET>,
            Logon: Logon::<Identity, OFFSET>,
            SpoolerLogon: SpoolerLogon::<Identity, OFFSET>,
            CompareStoreIDs: CompareStoreIDs::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMSProvider as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMSProvider {}
pub const IMSProvider_CompareStoreIDs: METHODS = METHODS(111i32);
pub const IMSProvider_Logon: METHODS = METHODS(109i32);
pub const IMSProvider_Shutdown: METHODS = METHODS(108i32);
pub const IMSProvider_SpoolerLogon: METHODS = METHODS(110i32);
windows_core::imp::define_interface!(
    IMailUser,
    IMailUser_Vtbl,
    0x0002030a_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMailUser {
    type Target = IMAPIProp;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(IMailUser, windows_core::IUnknown, IMAPIProp);
#[repr(C)]
pub struct IMailUser_Vtbl {
    pub base__: IMAPIProp_Vtbl,
}
pub trait IMailUser_Impl: IMAPIProp_Impl {}
impl IMailUser_Vtbl {
    pub const fn new<Identity: IMailUser_Impl, const OFFSET: isize>() -> Self {
        Self {
            base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMailUser as windows_core::Interface>::IID
            || iid == &<IMAPIProp as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMailUser {}
windows_core::imp::define_interface!(
    IMessage,
    IMessage_Vtbl,
    0x00020307_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMessage {
    type Target = IMAPIProp;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(IMessage, windows_core::IUnknown, IMAPIProp);
impl IMessage {
    pub unsafe fn GetAttachmentTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetAttachmentTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn OpenAttach(
        &self,
        ulattachmentnum: u32,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppattach: *mut Option<IAttach>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenAttach)(
                windows_core::Interface::as_raw(self),
                ulattachmentnum,
                lpinterface as _,
                ulflags,
                core::mem::transmute(lppattach),
            )
            .ok()
        }
    }
    pub unsafe fn CreateAttach(
        &self,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulattachmentnum: *mut u32,
        lppattach: *mut Option<IAttach>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CreateAttach)(
                windows_core::Interface::as_raw(self),
                lpinterface as _,
                ulflags,
                lpulattachmentnum as _,
                core::mem::transmute(lppattach),
            )
            .ok()
        }
    }
    pub unsafe fn DeleteAttach<P2>(
        &self,
        ulattachmentnum: u32,
        uluiparam: usize,
        lpprogress: P2,
        ulflags: u32,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<IMAPIProgress>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteAttach)(
                windows_core::Interface::as_raw(self),
                ulattachmentnum,
                uluiparam,
                lpprogress.param().abi(),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetRecipientTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetRecipientTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn ModifyRecipients(
        &self,
        ulflags: u32,
        lpmods: *mut ADRLIST,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ModifyRecipients)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpmods as _,
            )
            .ok()
        }
    }
    pub unsafe fn SubmitMessage(&self, ulflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SubmitMessage)(
                windows_core::Interface::as_raw(self),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn SetReadFlag(&self, ulflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetReadFlag)(
                windows_core::Interface::as_raw(self),
                ulflags,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMessage_Vtbl {
    pub base__: IMAPIProp_Vtbl,
    pub GetAttachmentTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub OpenAttach: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut windows_core::GUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CreateAttach: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        u32,
        *mut u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub DeleteAttach: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        usize,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub GetRecipientTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ModifyRecipients: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ADRLIST,
    ) -> windows_core::HRESULT,
    pub SubmitMessage:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub SetReadFlag:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
}
pub trait IMessage_Impl: IMAPIProp_Impl {
    fn GetAttachmentTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn OpenAttach(
        &self,
        ulattachmentnum: u32,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppattach: windows_core::OutRef<'_, IAttach>,
    ) -> windows_core::Result<()>;
    fn CreateAttach(
        &self,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulattachmentnum: *mut u32,
        lppattach: windows_core::OutRef<'_, IAttach>,
    ) -> windows_core::Result<()>;
    fn DeleteAttach(
        &self,
        ulattachmentnum: u32,
        uluiparam: usize,
        lpprogress: windows_core::Ref<'_, IMAPIProgress>,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn GetRecipientTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn ModifyRecipients(&self, ulflags: u32, lpmods: *mut ADRLIST) -> windows_core::Result<()>;
    fn SubmitMessage(&self, ulflags: u32) -> windows_core::Result<()>;
    fn SetReadFlag(&self, ulflags: u32) -> windows_core::Result<()>;
}
impl IMessage_Vtbl {
    pub const fn new<Identity: IMessage_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetAttachmentTable<
            Identity: IMessage_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMessage_Impl::GetAttachmentTable(this, core::mem::transmute_copy(&ulflags)) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn OpenAttach<Identity: IMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulattachmentnum: u32,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lppattach: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMessage_Impl::OpenAttach(
                    this,
                    core::mem::transmute_copy(&ulattachmentnum),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppattach),
                )
                .into()
            }
        }
        unsafe extern "system" fn CreateAttach<Identity: IMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lpulattachmentnum: *mut u32,
            lppattach: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMessage_Impl::CreateAttach(
                    this,
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulattachmentnum),
                    core::mem::transmute_copy(&lppattach),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteAttach<Identity: IMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulattachmentnum: u32,
            uluiparam: usize,
            lpprogress: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMessage_Impl::DeleteAttach(
                    this,
                    core::mem::transmute_copy(&ulattachmentnum),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpprogress),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetRecipientTable<
            Identity: IMessage_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMessage_Impl::GetRecipientTable(this, core::mem::transmute_copy(&ulflags)) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn ModifyRecipients<Identity: IMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpmods: *mut ADRLIST,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMessage_Impl::ModifyRecipients(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpmods),
                )
                .into()
            }
        }
        unsafe extern "system" fn SubmitMessage<Identity: IMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMessage_Impl::SubmitMessage(this, core::mem::transmute_copy(&ulflags)).into()
            }
        }
        unsafe extern "system" fn SetReadFlag<Identity: IMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMessage_Impl::SetReadFlag(this, core::mem::transmute_copy(&ulflags)).into()
            }
        }
        Self {
            base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
            GetAttachmentTable: GetAttachmentTable::<Identity, OFFSET>,
            OpenAttach: OpenAttach::<Identity, OFFSET>,
            CreateAttach: CreateAttach::<Identity, OFFSET>,
            DeleteAttach: DeleteAttach::<Identity, OFFSET>,
            GetRecipientTable: GetRecipientTable::<Identity, OFFSET>,
            ModifyRecipients: ModifyRecipients::<Identity, OFFSET>,
            SubmitMessage: SubmitMessage::<Identity, OFFSET>,
            SetReadFlag: SetReadFlag::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMessage as windows_core::Interface>::IID
            || iid == &<IMAPIProp as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMessage {}
pub const IMessage_CreateAttach: METHODS = METHODS(76i32);
pub const IMessage_DeleteAttach: METHODS = METHODS(77i32);
pub const IMessage_GetAttachmentTable: METHODS = METHODS(74i32);
pub const IMessage_GetRecipientTable: METHODS = METHODS(78i32);
pub const IMessage_ModifyRecipients: METHODS = METHODS(79i32);
pub const IMessage_OpenAttach: METHODS = METHODS(75i32);
pub const IMessage_SetReadFlag: METHODS = METHODS(81i32);
pub const IMessage_SubmitMessage: METHODS = METHODS(80i32);
windows_core::imp::define_interface!(
    IMimeAddressTable,
    IMimeAddressTable_Vtbl,
    0xc558834a_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeAddressTable, windows_core::IUnknown);
impl IMimeAddressTable {
    pub unsafe fn Append<P2, P3>(
        &self,
        dwadrtype: u32,
        ietfriendly: ENCODINGTYPE,
        pszfriendly: P2,
        pszemail: P3,
        phaddress: *mut *mut HADDRESS__,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<windows_core::PCSTR>,
        P3: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Append)(
                windows_core::Interface::as_raw(self),
                dwadrtype,
                ietfriendly,
                pszfriendly.param().abi(),
                pszemail.param().abi(),
                phaddress as _,
            )
            .ok()
        }
    }
    pub unsafe fn Insert(
        &self,
        paddress: *mut ADDRESSPROPS,
        phaddress: *mut *mut HADDRESS__,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Insert)(
                windows_core::Interface::as_raw(self),
                paddress as _,
                phaddress as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetProps(
        &self,
        haddress: *mut HADDRESS__,
        paddress: *mut ADDRESSPROPS,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetProps)(
                windows_core::Interface::as_raw(self),
                haddress as _,
                paddress as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetProps(
        &self,
        haddress: *mut HADDRESS__,
        paddress: *mut ADDRESSPROPS,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetProps)(
                windows_core::Interface::as_raw(self),
                haddress as _,
                paddress as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetSender(&self, paddress: *mut ADDRESSPROPS) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetSender)(
                windows_core::Interface::as_raw(self),
                paddress as _,
            )
            .ok()
        }
    }
    pub unsafe fn CountTypes(&self, dwadrtypes: u32, pcadrs: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CountTypes)(
                windows_core::Interface::as_raw(self),
                dwadrtypes,
                pcadrs as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetTypes(
        &self,
        dwadrtypes: u32,
        dwprops: u32,
        plist: *mut ADDRESSLIST,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetTypes)(
                windows_core::Interface::as_raw(self),
                dwadrtypes,
                dwprops,
                plist as _,
            )
            .ok()
        }
    }
    pub unsafe fn EnumTypes(
        &self,
        dwadrtypes: u32,
        dwprops: u32,
    ) -> windows_core::Result<IMimeEnumAddressTypes> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).EnumTypes)(
                windows_core::Interface::as_raw(self),
                dwadrtypes,
                dwprops,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn Delete(&self, haddress: *mut HADDRESS__) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Delete)(
                windows_core::Interface::as_raw(self),
                haddress as _,
            )
            .ok()
        }
    }
    pub unsafe fn DeleteTypes(&self, dwadrtypes: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteTypes)(
                windows_core::Interface::as_raw(self),
                dwadrtypes,
            )
            .ok()
        }
    }
    pub unsafe fn GetFormat(
        &self,
        dwadrtype: u32,
        format: ADDRESSFORMAT,
        ppszformat: *mut windows_core::PSTR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetFormat)(
                windows_core::Interface::as_raw(self),
                dwadrtype,
                format,
                ppszformat as _,
            )
            .ok()
        }
    }
    pub unsafe fn AppendRfc822<P2>(
        &self,
        dwadrtype: u32,
        ietencoding: ENCODINGTYPE,
        pszrfc822adr: P2,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).AppendRfc822)(
                windows_core::Interface::as_raw(self),
                dwadrtype,
                ietencoding,
                pszrfc822adr.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn ParseRfc822<P2>(
        &self,
        dwadrtype: u32,
        ietencoding: ENCODINGTYPE,
        pszrfc822adr: P2,
        plist: *mut ADDRESSLIST,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).ParseRfc822)(
                windows_core::Interface::as_raw(self),
                dwadrtype,
                ietencoding,
                pszrfc822adr.param().abi(),
                plist as _,
            )
            .ok()
        }
    }
    pub unsafe fn Clone(&self) -> windows_core::Result<IMimeAddressTable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).Clone)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn BindToObject(
        &self,
        riid: *const windows_core::GUID,
        ppvobject: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).BindToObject)(
                windows_core::Interface::as_raw(self),
                riid,
                ppvobject as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeAddressTable_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Append: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        ENCODINGTYPE,
        windows_core::PCSTR,
        windows_core::PCSTR,
        *mut *mut HADDRESS__,
    ) -> windows_core::HRESULT,
    pub Insert: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut ADDRESSPROPS,
        *mut *mut HADDRESS__,
    ) -> windows_core::HRESULT,
    pub SetProps: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HADDRESS__,
        *mut ADDRESSPROPS,
    ) -> windows_core::HRESULT,
    pub GetProps: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HADDRESS__,
        *mut ADDRESSPROPS,
    ) -> windows_core::HRESULT,
    pub GetSender: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut ADDRESSPROPS,
    ) -> windows_core::HRESULT,
    pub CountTypes:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut u32) -> windows_core::HRESULT,
    pub GetTypes: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut ADDRESSLIST,
    ) -> windows_core::HRESULT,
    pub EnumTypes: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Delete:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut HADDRESS__) -> windows_core::HRESULT,
    pub DeleteTypes:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub GetFormat: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        ADDRESSFORMAT,
        *mut windows_core::PSTR,
    ) -> windows_core::HRESULT,
    pub AppendRfc822: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        ENCODINGTYPE,
        windows_core::PCSTR,
    ) -> windows_core::HRESULT,
    pub ParseRfc822: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        ENCODINGTYPE,
        windows_core::PCSTR,
        *mut ADDRESSLIST,
    ) -> windows_core::HRESULT,
    pub Clone: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub BindToObject: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *const windows_core::GUID,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMimeAddressTable_Impl: windows_core::IUnknownImpl {
    fn Append(
        &self,
        dwadrtype: u32,
        ietfriendly: ENCODINGTYPE,
        pszfriendly: &windows_core::PCSTR,
        pszemail: &windows_core::PCSTR,
        phaddress: *mut *mut HADDRESS__,
    ) -> windows_core::Result<()>;
    fn Insert(
        &self,
        paddress: *mut ADDRESSPROPS,
        phaddress: *mut *mut HADDRESS__,
    ) -> windows_core::Result<()>;
    fn SetProps(
        &self,
        haddress: *mut HADDRESS__,
        paddress: *mut ADDRESSPROPS,
    ) -> windows_core::Result<()>;
    fn GetProps(
        &self,
        haddress: *mut HADDRESS__,
        paddress: *mut ADDRESSPROPS,
    ) -> windows_core::Result<()>;
    fn GetSender(&self, paddress: *mut ADDRESSPROPS) -> windows_core::Result<()>;
    fn CountTypes(&self, dwadrtypes: u32, pcadrs: *mut u32) -> windows_core::Result<()>;
    fn GetTypes(
        &self,
        dwadrtypes: u32,
        dwprops: u32,
        plist: *mut ADDRESSLIST,
    ) -> windows_core::Result<()>;
    fn EnumTypes(
        &self,
        dwadrtypes: u32,
        dwprops: u32,
    ) -> windows_core::Result<IMimeEnumAddressTypes>;
    fn Delete(&self, haddress: *mut HADDRESS__) -> windows_core::Result<()>;
    fn DeleteTypes(&self, dwadrtypes: u32) -> windows_core::Result<()>;
    fn GetFormat(
        &self,
        dwadrtype: u32,
        format: ADDRESSFORMAT,
        ppszformat: *mut windows_core::PSTR,
    ) -> windows_core::Result<()>;
    fn AppendRfc822(
        &self,
        dwadrtype: u32,
        ietencoding: ENCODINGTYPE,
        pszrfc822adr: &windows_core::PCSTR,
    ) -> windows_core::Result<()>;
    fn ParseRfc822(
        &self,
        dwadrtype: u32,
        ietencoding: ENCODINGTYPE,
        pszrfc822adr: &windows_core::PCSTR,
        plist: *mut ADDRESSLIST,
    ) -> windows_core::Result<()>;
    fn Clone(&self) -> windows_core::Result<IMimeAddressTable>;
    fn BindToObject(
        &self,
        riid: *const windows_core::GUID,
        ppvobject: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()>;
}
impl IMimeAddressTable_Vtbl {
    pub const fn new<Identity: IMimeAddressTable_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Append<Identity: IMimeAddressTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            dwadrtype: u32,
            ietfriendly: ENCODINGTYPE,
            pszfriendly: windows_core::PCSTR,
            pszemail: windows_core::PCSTR,
            phaddress: *mut *mut HADDRESS__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAddressTable_Impl::Append(
                    this,
                    core::mem::transmute_copy(&dwadrtype),
                    core::mem::transmute_copy(&ietfriendly),
                    core::mem::transmute(&pszfriendly),
                    core::mem::transmute(&pszemail),
                    core::mem::transmute_copy(&phaddress),
                )
                .into()
            }
        }
        unsafe extern "system" fn Insert<Identity: IMimeAddressTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            paddress: *mut ADDRESSPROPS,
            phaddress: *mut *mut HADDRESS__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAddressTable_Impl::Insert(
                    this,
                    core::mem::transmute_copy(&paddress),
                    core::mem::transmute_copy(&phaddress),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetProps<
            Identity: IMimeAddressTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            haddress: *mut HADDRESS__,
            paddress: *mut ADDRESSPROPS,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAddressTable_Impl::SetProps(
                    this,
                    core::mem::transmute_copy(&haddress),
                    core::mem::transmute_copy(&paddress),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetProps<
            Identity: IMimeAddressTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            haddress: *mut HADDRESS__,
            paddress: *mut ADDRESSPROPS,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAddressTable_Impl::GetProps(
                    this,
                    core::mem::transmute_copy(&haddress),
                    core::mem::transmute_copy(&paddress),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetSender<
            Identity: IMimeAddressTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            paddress: *mut ADDRESSPROPS,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAddressTable_Impl::GetSender(this, core::mem::transmute_copy(&paddress)).into()
            }
        }
        unsafe extern "system" fn CountTypes<
            Identity: IMimeAddressTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwadrtypes: u32,
            pcadrs: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAddressTable_Impl::CountTypes(
                    this,
                    core::mem::transmute_copy(&dwadrtypes),
                    core::mem::transmute_copy(&pcadrs),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetTypes<
            Identity: IMimeAddressTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwadrtypes: u32,
            dwprops: u32,
            plist: *mut ADDRESSLIST,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAddressTable_Impl::GetTypes(
                    this,
                    core::mem::transmute_copy(&dwadrtypes),
                    core::mem::transmute_copy(&dwprops),
                    core::mem::transmute_copy(&plist),
                )
                .into()
            }
        }
        unsafe extern "system" fn EnumTypes<
            Identity: IMimeAddressTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwadrtypes: u32,
            dwprops: u32,
            ppenum: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeAddressTable_Impl::EnumTypes(
                    this,
                    core::mem::transmute_copy(&dwadrtypes),
                    core::mem::transmute_copy(&dwprops),
                ) {
                    Ok(ok__) => {
                        ppenum.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn Delete<Identity: IMimeAddressTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            haddress: *mut HADDRESS__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAddressTable_Impl::Delete(this, core::mem::transmute_copy(&haddress)).into()
            }
        }
        unsafe extern "system" fn DeleteTypes<
            Identity: IMimeAddressTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwadrtypes: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAddressTable_Impl::DeleteTypes(this, core::mem::transmute_copy(&dwadrtypes))
                    .into()
            }
        }
        unsafe extern "system" fn GetFormat<
            Identity: IMimeAddressTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwadrtype: u32,
            format: ADDRESSFORMAT,
            ppszformat: *mut windows_core::PSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAddressTable_Impl::GetFormat(
                    this,
                    core::mem::transmute_copy(&dwadrtype),
                    core::mem::transmute_copy(&format),
                    core::mem::transmute_copy(&ppszformat),
                )
                .into()
            }
        }
        unsafe extern "system" fn AppendRfc822<
            Identity: IMimeAddressTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwadrtype: u32,
            ietencoding: ENCODINGTYPE,
            pszrfc822adr: windows_core::PCSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAddressTable_Impl::AppendRfc822(
                    this,
                    core::mem::transmute_copy(&dwadrtype),
                    core::mem::transmute_copy(&ietencoding),
                    core::mem::transmute(&pszrfc822adr),
                )
                .into()
            }
        }
        unsafe extern "system" fn ParseRfc822<
            Identity: IMimeAddressTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwadrtype: u32,
            ietencoding: ENCODINGTYPE,
            pszrfc822adr: windows_core::PCSTR,
            plist: *mut ADDRESSLIST,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAddressTable_Impl::ParseRfc822(
                    this,
                    core::mem::transmute_copy(&dwadrtype),
                    core::mem::transmute_copy(&ietencoding),
                    core::mem::transmute(&pszrfc822adr),
                    core::mem::transmute_copy(&plist),
                )
                .into()
            }
        }
        unsafe extern "system" fn Clone<Identity: IMimeAddressTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeAddressTable_Impl::Clone(this) {
                    Ok(ok__) => {
                        pptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn BindToObject<
            Identity: IMimeAddressTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            riid: *const windows_core::GUID,
            ppvobject: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAddressTable_Impl::BindToObject(
                    this,
                    core::mem::transmute_copy(&riid),
                    core::mem::transmute_copy(&ppvobject),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Append: Append::<Identity, OFFSET>,
            Insert: Insert::<Identity, OFFSET>,
            SetProps: SetProps::<Identity, OFFSET>,
            GetProps: GetProps::<Identity, OFFSET>,
            GetSender: GetSender::<Identity, OFFSET>,
            CountTypes: CountTypes::<Identity, OFFSET>,
            GetTypes: GetTypes::<Identity, OFFSET>,
            EnumTypes: EnumTypes::<Identity, OFFSET>,
            Delete: Delete::<Identity, OFFSET>,
            DeleteTypes: DeleteTypes::<Identity, OFFSET>,
            GetFormat: GetFormat::<Identity, OFFSET>,
            AppendRfc822: AppendRfc822::<Identity, OFFSET>,
            ParseRfc822: ParseRfc822::<Identity, OFFSET>,
            Clone: Clone::<Identity, OFFSET>,
            BindToObject: BindToObject::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeAddressTable as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeAddressTable {}
windows_core::imp::define_interface!(
    IMimeAllocator,
    IMimeAllocator_Vtbl,
    0xc5588351_7f86_11d0_8252_00c04fd85ab4
);
impl core::ops::Deref for IMimeAllocator {
    type Target = windows::Win32::System::Com::IMalloc;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IMimeAllocator,
    windows_core::IUnknown,
    windows::Win32::System::Com::IMalloc
);
impl IMimeAllocator {
    pub unsafe fn FreeParamInfoArray(
        &self,
        cparams: u32,
        prgparam: *mut MIMEPARAMINFO,
        ffreearray: u8,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FreeParamInfoArray)(
                windows_core::Interface::as_raw(self),
                cparams,
                prgparam as _,
                ffreearray,
            )
            .ok()
        }
    }
    pub unsafe fn FreeAddressList(&self, plist: *mut ADDRESSLIST) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FreeAddressList)(
                windows_core::Interface::as_raw(self),
                plist as _,
            )
            .ok()
        }
    }
    pub unsafe fn FreeAddressProps(&self, paddress: *mut ADDRESSPROPS) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FreeAddressProps)(
                windows_core::Interface::as_raw(self),
                paddress as _,
            )
            .ok()
        }
    }
    pub unsafe fn ReleaseObjects(
        &self,
        cobjects: u32,
        prgpunknown: *mut Option<windows_core::IUnknown>,
        ffreearray: u8,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ReleaseObjects)(
                windows_core::Interface::as_raw(self),
                cobjects,
                core::mem::transmute(prgpunknown),
                ffreearray,
            )
            .ok()
        }
    }
    pub unsafe fn FreeEnumHeaderRowArray(
        &self,
        crows: u32,
        prgrow: *mut ENUMHEADERROW,
        ffreearray: u8,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FreeEnumHeaderRowArray)(
                windows_core::Interface::as_raw(self),
                crows,
                prgrow as _,
                ffreearray,
            )
            .ok()
        }
    }
    pub unsafe fn FreeEnumPropertyArray(
        &self,
        cprops: u32,
        prgprop: *mut ENUMPROPERTY,
        ffreearray: u8,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FreeEnumPropertyArray)(
                windows_core::Interface::as_raw(self),
                cprops,
                prgprop as _,
                ffreearray,
            )
            .ok()
        }
    }
    pub unsafe fn FreeThumbprint(
        &self,
        pthumbprint: *mut windows::Win32::System::Com::BLOB,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FreeThumbprint)(
                windows_core::Interface::as_raw(self),
                pthumbprint as _,
            )
            .ok()
        }
    }
    pub unsafe fn PropVariantClear(
        &self,
        pprop: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PropVariantClear)(
                windows_core::Interface::as_raw(self),
                core::mem::transmute(pprop),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeAllocator_Vtbl {
    pub base__: windows::Win32::System::Com::IMalloc_Vtbl,
    pub FreeParamInfoArray: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut MIMEPARAMINFO,
        u8,
    ) -> windows_core::HRESULT,
    pub FreeAddressList: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut ADDRESSLIST,
    ) -> windows_core::HRESULT,
    pub FreeAddressProps: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut ADDRESSPROPS,
    ) -> windows_core::HRESULT,
    pub ReleaseObjects: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
        u8,
    ) -> windows_core::HRESULT,
    pub FreeEnumHeaderRowArray: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENUMHEADERROW,
        u8,
    ) -> windows_core::HRESULT,
    pub FreeEnumPropertyArray: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENUMPROPERTY,
        u8,
    ) -> windows_core::HRESULT,
    pub FreeThumbprint: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows::Win32::System::Com::BLOB,
    ) -> windows_core::HRESULT,
    pub PropVariantClear: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
}
pub trait IMimeAllocator_Impl: windows::Win32::System::Com::IMalloc_Impl {
    fn FreeParamInfoArray(
        &self,
        cparams: u32,
        prgparam: *mut MIMEPARAMINFO,
        ffreearray: u8,
    ) -> windows_core::Result<()>;
    fn FreeAddressList(&self, plist: *mut ADDRESSLIST) -> windows_core::Result<()>;
    fn FreeAddressProps(&self, paddress: *mut ADDRESSPROPS) -> windows_core::Result<()>;
    fn ReleaseObjects(
        &self,
        cobjects: u32,
        prgpunknown: windows_core::OutRef<'_, windows_core::IUnknown>,
        ffreearray: u8,
    ) -> windows_core::Result<()>;
    fn FreeEnumHeaderRowArray(
        &self,
        crows: u32,
        prgrow: *mut ENUMHEADERROW,
        ffreearray: u8,
    ) -> windows_core::Result<()>;
    fn FreeEnumPropertyArray(
        &self,
        cprops: u32,
        prgprop: *mut ENUMPROPERTY,
        ffreearray: u8,
    ) -> windows_core::Result<()>;
    fn FreeThumbprint(
        &self,
        pthumbprint: *mut windows::Win32::System::Com::BLOB,
    ) -> windows_core::Result<()>;
    fn PropVariantClear(
        &self,
        pprop: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
}
impl IMimeAllocator_Vtbl {
    pub const fn new<Identity: IMimeAllocator_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn FreeParamInfoArray<
            Identity: IMimeAllocator_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cparams: u32,
            prgparam: *mut MIMEPARAMINFO,
            ffreearray: u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAllocator_Impl::FreeParamInfoArray(
                    this,
                    core::mem::transmute_copy(&cparams),
                    core::mem::transmute_copy(&prgparam),
                    core::mem::transmute_copy(&ffreearray),
                )
                .into()
            }
        }
        unsafe extern "system" fn FreeAddressList<
            Identity: IMimeAllocator_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            plist: *mut ADDRESSLIST,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAllocator_Impl::FreeAddressList(this, core::mem::transmute_copy(&plist)).into()
            }
        }
        unsafe extern "system" fn FreeAddressProps<
            Identity: IMimeAllocator_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            paddress: *mut ADDRESSPROPS,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAllocator_Impl::FreeAddressProps(this, core::mem::transmute_copy(&paddress))
                    .into()
            }
        }
        unsafe extern "system" fn ReleaseObjects<
            Identity: IMimeAllocator_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cobjects: u32,
            prgpunknown: *mut *mut core::ffi::c_void,
            ffreearray: u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAllocator_Impl::ReleaseObjects(
                    this,
                    core::mem::transmute_copy(&cobjects),
                    core::mem::transmute_copy(&prgpunknown),
                    core::mem::transmute_copy(&ffreearray),
                )
                .into()
            }
        }
        unsafe extern "system" fn FreeEnumHeaderRowArray<
            Identity: IMimeAllocator_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            crows: u32,
            prgrow: *mut ENUMHEADERROW,
            ffreearray: u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAllocator_Impl::FreeEnumHeaderRowArray(
                    this,
                    core::mem::transmute_copy(&crows),
                    core::mem::transmute_copy(&prgrow),
                    core::mem::transmute_copy(&ffreearray),
                )
                .into()
            }
        }
        unsafe extern "system" fn FreeEnumPropertyArray<
            Identity: IMimeAllocator_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cprops: u32,
            prgprop: *mut ENUMPROPERTY,
            ffreearray: u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAllocator_Impl::FreeEnumPropertyArray(
                    this,
                    core::mem::transmute_copy(&cprops),
                    core::mem::transmute_copy(&prgprop),
                    core::mem::transmute_copy(&ffreearray),
                )
                .into()
            }
        }
        unsafe extern "system" fn FreeThumbprint<
            Identity: IMimeAllocator_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pthumbprint: *mut windows::Win32::System::Com::BLOB,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAllocator_Impl::FreeThumbprint(this, core::mem::transmute_copy(&pthumbprint))
                    .into()
            }
        }
        unsafe extern "system" fn PropVariantClear<
            Identity: IMimeAllocator_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pprop: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeAllocator_Impl::PropVariantClear(this, core::mem::transmute_copy(&pprop))
                    .into()
            }
        }
        Self {
            base__: windows::Win32::System::Com::IMalloc_Vtbl::new::<Identity, OFFSET>(),
            FreeParamInfoArray: FreeParamInfoArray::<Identity, OFFSET>,
            FreeAddressList: FreeAddressList::<Identity, OFFSET>,
            FreeAddressProps: FreeAddressProps::<Identity, OFFSET>,
            ReleaseObjects: ReleaseObjects::<Identity, OFFSET>,
            FreeEnumHeaderRowArray: FreeEnumHeaderRowArray::<Identity, OFFSET>,
            FreeEnumPropertyArray: FreeEnumPropertyArray::<Identity, OFFSET>,
            FreeThumbprint: FreeThumbprint::<Identity, OFFSET>,
            PropVariantClear: PropVariantClear::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeAllocator as windows_core::Interface>::IID
            || iid == &<windows::Win32::System::Com::IMalloc as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeAllocator {}
windows_core::imp::define_interface!(
    IMimeBody,
    IMimeBody_Vtbl,
    0xc558834c_7f86_11d0_8252_00c04fd85ab4
);
impl core::ops::Deref for IMimeBody {
    type Target = IMimePropertySet;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IMimeBody,
    windows_core::IUnknown,
    windows::Win32::System::Com::IPersist,
    windows::Win32::System::Com::IPersistStreamInit,
    IMimePropertySet
);
impl IMimeBody {
    pub unsafe fn IsType(&self, bodytype: IMSGBODYTYPE) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).IsType)(
                windows_core::Interface::as_raw(self),
                bodytype,
            )
            .ok()
        }
    }
    pub unsafe fn SetDisplayName<P0>(&self, pszdisplay: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SetDisplayName)(
                windows_core::Interface::as_raw(self),
                pszdisplay.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn GetDisplayName(
        &self,
        ppszdisplay: *mut windows_core::PSTR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetDisplayName)(
                windows_core::Interface::as_raw(self),
                ppszdisplay as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetOffsets(&self, poffsets: *mut BODYOFFSETS) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetOffsets)(
                windows_core::Interface::as_raw(self),
                poffsets as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetCurrentEncoding(
        &self,
        pietencoding: *mut ENCODINGTYPE,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetCurrentEncoding)(
                windows_core::Interface::as_raw(self),
                pietencoding as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetCurrentEncoding(&self, ietencoding: ENCODINGTYPE) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetCurrentEncoding)(
                windows_core::Interface::as_raw(self),
                ietencoding,
            )
            .ok()
        }
    }
    pub unsafe fn GetEstimatedSize(
        &self,
        ietencoding: ENCODINGTYPE,
        pcbsize: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetEstimatedSize)(
                windows_core::Interface::as_raw(self),
                ietencoding,
                pcbsize as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetDataHere<P1>(
        &self,
        ietencoding: ENCODINGTYPE,
        pstream: P1,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetDataHere)(
                windows_core::Interface::as_raw(self),
                ietencoding,
                pstream.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn GetData(
        &self,
        ietencoding: ENCODINGTYPE,
    ) -> windows_core::Result<windows::Win32::System::Com::IStream> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetData)(
                windows_core::Interface::as_raw(self),
                ietencoding,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn SetData<P1, P2>(
        &self,
        ietencoding: ENCODINGTYPE,
        pszpritype: P1,
        pszsubtype: P2,
        riid: *const windows_core::GUID,
        pvobject: *mut core::ffi::c_void,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows_core::PCSTR>,
        P2: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SetData)(
                windows_core::Interface::as_raw(self),
                ietencoding,
                pszpritype.param().abi(),
                pszsubtype.param().abi(),
                riid,
                pvobject as _,
            )
            .ok()
        }
    }
    pub unsafe fn EmptyData(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).EmptyData)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn CopyTo<P0>(&self, pbody: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMimeBody>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CopyTo)(
                windows_core::Interface::as_raw(self),
                pbody.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn GetTransmitInfo(
        &self,
        ptransmitinfo: *mut TRANSMITINFO,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetTransmitInfo)(
                windows_core::Interface::as_raw(self),
                ptransmitinfo as _,
            )
            .ok()
        }
    }
    pub unsafe fn SaveToFile<P1>(
        &self,
        ietencoding: ENCODINGTYPE,
        pszfilepath: P1,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SaveToFile)(
                windows_core::Interface::as_raw(self),
                ietencoding,
                pszfilepath.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn GetHandle(&self, phbody: *mut *mut HBODY__) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetHandle)(
                windows_core::Interface::as_raw(self),
                phbody as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeBody_Vtbl {
    pub base__: IMimePropertySet_Vtbl,
    pub IsType:
        unsafe extern "system" fn(*mut core::ffi::c_void, IMSGBODYTYPE) -> windows_core::HRESULT,
    pub SetDisplayName: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
    ) -> windows_core::HRESULT,
    pub GetDisplayName: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::PSTR,
    ) -> windows_core::HRESULT,
    pub GetOffsets: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut BODYOFFSETS,
    ) -> windows_core::HRESULT,
    pub GetCurrentEncoding: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut ENCODINGTYPE,
    ) -> windows_core::HRESULT,
    pub SetCurrentEncoding:
        unsafe extern "system" fn(*mut core::ffi::c_void, ENCODINGTYPE) -> windows_core::HRESULT,
    pub GetEstimatedSize: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        ENCODINGTYPE,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub GetDataHere: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        ENCODINGTYPE,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetData: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        ENCODINGTYPE,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SetData: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        ENCODINGTYPE,
        windows_core::PCSTR,
        windows_core::PCSTR,
        *const windows_core::GUID,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub EmptyData: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub CopyTo: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetTransmitInfo: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut TRANSMITINFO,
    ) -> windows_core::HRESULT,
    pub SaveToFile: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        ENCODINGTYPE,
        windows_core::PCSTR,
    ) -> windows_core::HRESULT,
    pub GetHandle: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut HBODY__,
    ) -> windows_core::HRESULT,
}
pub trait IMimeBody_Impl: IMimePropertySet_Impl {
    fn IsType(&self, bodytype: IMSGBODYTYPE) -> windows_core::Result<()>;
    fn SetDisplayName(&self, pszdisplay: &windows_core::PCSTR) -> windows_core::Result<()>;
    fn GetDisplayName(&self, ppszdisplay: *mut windows_core::PSTR) -> windows_core::Result<()>;
    fn GetOffsets(&self, poffsets: *mut BODYOFFSETS) -> windows_core::Result<()>;
    fn GetCurrentEncoding(&self, pietencoding: *mut ENCODINGTYPE) -> windows_core::Result<()>;
    fn SetCurrentEncoding(&self, ietencoding: ENCODINGTYPE) -> windows_core::Result<()>;
    fn GetEstimatedSize(
        &self,
        ietencoding: ENCODINGTYPE,
        pcbsize: *mut u32,
    ) -> windows_core::Result<()>;
    fn GetDataHere(
        &self,
        ietencoding: ENCODINGTYPE,
        pstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()>;
    fn GetData(
        &self,
        ietencoding: ENCODINGTYPE,
    ) -> windows_core::Result<windows::Win32::System::Com::IStream>;
    fn SetData(
        &self,
        ietencoding: ENCODINGTYPE,
        pszpritype: &windows_core::PCSTR,
        pszsubtype: &windows_core::PCSTR,
        riid: *const windows_core::GUID,
        pvobject: *mut core::ffi::c_void,
    ) -> windows_core::Result<()>;
    fn EmptyData(&self) -> windows_core::Result<()>;
    fn CopyTo(&self, pbody: windows_core::Ref<'_, IMimeBody>) -> windows_core::Result<()>;
    fn GetTransmitInfo(&self, ptransmitinfo: *mut TRANSMITINFO) -> windows_core::Result<()>;
    fn SaveToFile(
        &self,
        ietencoding: ENCODINGTYPE,
        pszfilepath: &windows_core::PCSTR,
    ) -> windows_core::Result<()>;
    fn GetHandle(&self, phbody: *mut *mut HBODY__) -> windows_core::Result<()>;
}
impl IMimeBody_Vtbl {
    pub const fn new<Identity: IMimeBody_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn IsType<Identity: IMimeBody_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            bodytype: IMSGBODYTYPE,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::IsType(this, core::mem::transmute_copy(&bodytype)).into()
            }
        }
        unsafe extern "system" fn SetDisplayName<Identity: IMimeBody_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pszdisplay: windows_core::PCSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::SetDisplayName(this, core::mem::transmute(&pszdisplay)).into()
            }
        }
        unsafe extern "system" fn GetDisplayName<Identity: IMimeBody_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ppszdisplay: *mut windows_core::PSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::GetDisplayName(this, core::mem::transmute_copy(&ppszdisplay)).into()
            }
        }
        unsafe extern "system" fn GetOffsets<Identity: IMimeBody_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            poffsets: *mut BODYOFFSETS,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::GetOffsets(this, core::mem::transmute_copy(&poffsets)).into()
            }
        }
        unsafe extern "system" fn GetCurrentEncoding<
            Identity: IMimeBody_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pietencoding: *mut ENCODINGTYPE,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::GetCurrentEncoding(this, core::mem::transmute_copy(&pietencoding))
                    .into()
            }
        }
        unsafe extern "system" fn SetCurrentEncoding<
            Identity: IMimeBody_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ietencoding: ENCODINGTYPE,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::SetCurrentEncoding(this, core::mem::transmute_copy(&ietencoding))
                    .into()
            }
        }
        unsafe extern "system" fn GetEstimatedSize<
            Identity: IMimeBody_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ietencoding: ENCODINGTYPE,
            pcbsize: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::GetEstimatedSize(
                    this,
                    core::mem::transmute_copy(&ietencoding),
                    core::mem::transmute_copy(&pcbsize),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetDataHere<Identity: IMimeBody_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ietencoding: ENCODINGTYPE,
            pstream: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::GetDataHere(
                    this,
                    core::mem::transmute_copy(&ietencoding),
                    core::mem::transmute_copy(&pstream),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetData<Identity: IMimeBody_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ietencoding: ENCODINGTYPE,
            ppstream: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeBody_Impl::GetData(this, core::mem::transmute_copy(&ietencoding)) {
                    Ok(ok__) => {
                        ppstream.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn SetData<Identity: IMimeBody_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ietencoding: ENCODINGTYPE,
            pszpritype: windows_core::PCSTR,
            pszsubtype: windows_core::PCSTR,
            riid: *const windows_core::GUID,
            pvobject: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::SetData(
                    this,
                    core::mem::transmute_copy(&ietencoding),
                    core::mem::transmute(&pszpritype),
                    core::mem::transmute(&pszsubtype),
                    core::mem::transmute_copy(&riid),
                    core::mem::transmute_copy(&pvobject),
                )
                .into()
            }
        }
        unsafe extern "system" fn EmptyData<Identity: IMimeBody_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::EmptyData(this).into()
            }
        }
        unsafe extern "system" fn CopyTo<Identity: IMimeBody_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pbody: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::CopyTo(this, core::mem::transmute_copy(&pbody)).into()
            }
        }
        unsafe extern "system" fn GetTransmitInfo<Identity: IMimeBody_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ptransmitinfo: *mut TRANSMITINFO,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::GetTransmitInfo(this, core::mem::transmute_copy(&ptransmitinfo))
                    .into()
            }
        }
        unsafe extern "system" fn SaveToFile<Identity: IMimeBody_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ietencoding: ENCODINGTYPE,
            pszfilepath: windows_core::PCSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::SaveToFile(
                    this,
                    core::mem::transmute_copy(&ietencoding),
                    core::mem::transmute(&pszfilepath),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetHandle<Identity: IMimeBody_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            phbody: *mut *mut HBODY__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeBody_Impl::GetHandle(this, core::mem::transmute_copy(&phbody)).into()
            }
        }
        Self {
            base__: IMimePropertySet_Vtbl::new::<Identity, OFFSET>(),
            IsType: IsType::<Identity, OFFSET>,
            SetDisplayName: SetDisplayName::<Identity, OFFSET>,
            GetDisplayName: GetDisplayName::<Identity, OFFSET>,
            GetOffsets: GetOffsets::<Identity, OFFSET>,
            GetCurrentEncoding: GetCurrentEncoding::<Identity, OFFSET>,
            SetCurrentEncoding: SetCurrentEncoding::<Identity, OFFSET>,
            GetEstimatedSize: GetEstimatedSize::<Identity, OFFSET>,
            GetDataHere: GetDataHere::<Identity, OFFSET>,
            GetData: GetData::<Identity, OFFSET>,
            SetData: SetData::<Identity, OFFSET>,
            EmptyData: EmptyData::<Identity, OFFSET>,
            CopyTo: CopyTo::<Identity, OFFSET>,
            GetTransmitInfo: GetTransmitInfo::<Identity, OFFSET>,
            SaveToFile: SaveToFile::<Identity, OFFSET>,
            GetHandle: GetHandle::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == & < IMimeBody as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersist as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersistStreamInit as windows_core::Interface >::IID || iid == & < IMimePropertySet as windows_core::Interface >::IID
    }
}
impl windows_core::RuntimeName for IMimeBody {}
windows_core::imp::define_interface!(
    IMimeEditTag,
    IMimeEditTag_Vtbl,
    0x70183210_7b36_11d2_8c12_00c04fa31009
);
windows_core::imp::interface_hierarchy!(IMimeEditTag, windows_core::IUnknown);
impl IMimeEditTag {
    pub unsafe fn GetSrc(&self, pbstr: *mut windows_core::BSTR) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetSrc)(
                windows_core::Interface::as_raw(self),
                core::mem::transmute(pbstr),
            )
            .ok()
        }
    }
    pub unsafe fn SetSrc(&self, bstr: &windows_core::BSTR) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetSrc)(
                windows_core::Interface::as_raw(self),
                core::mem::transmute_copy(bstr),
            )
            .ok()
        }
    }
    pub unsafe fn GetDest(&self, pbstr: *mut windows_core::BSTR) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetDest)(
                windows_core::Interface::as_raw(self),
                core::mem::transmute(pbstr),
            )
            .ok()
        }
    }
    pub unsafe fn SetDest(&self, bstr: &windows_core::BSTR) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetDest)(
                windows_core::Interface::as_raw(self),
                core::mem::transmute_copy(bstr),
            )
            .ok()
        }
    }
    pub unsafe fn OnPreSave(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OnPreSave)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn OnPostSave(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OnPostSave)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn CanPackage(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CanPackage)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn IsValidMimeType<P0>(&self, psztypew: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCWSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).IsValidMimeType)(
                windows_core::Interface::as_raw(self),
                psztypew.param().abi(),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeEditTag_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetSrc: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SetSrc: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetDest: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SetDest: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub OnPreSave: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub OnPostSave: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub CanPackage: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub IsValidMimeType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCWSTR,
    ) -> windows_core::HRESULT,
}
pub trait IMimeEditTag_Impl: windows_core::IUnknownImpl {
    fn GetSrc(&self, pbstr: *mut windows_core::BSTR) -> windows_core::Result<()>;
    fn SetSrc(&self, bstr: &windows_core::BSTR) -> windows_core::Result<()>;
    fn GetDest(&self, pbstr: *mut windows_core::BSTR) -> windows_core::Result<()>;
    fn SetDest(&self, bstr: &windows_core::BSTR) -> windows_core::Result<()>;
    fn OnPreSave(&self) -> windows_core::Result<()>;
    fn OnPostSave(&self) -> windows_core::Result<()>;
    fn CanPackage(&self) -> windows_core::Result<()>;
    fn IsValidMimeType(&self, psztypew: &windows_core::PCWSTR) -> windows_core::Result<()>;
}
impl IMimeEditTag_Vtbl {
    pub const fn new<Identity: IMimeEditTag_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetSrc<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pbstr: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEditTag_Impl::GetSrc(this, core::mem::transmute_copy(&pbstr)).into()
            }
        }
        unsafe extern "system" fn SetSrc<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            bstr: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEditTag_Impl::SetSrc(this, core::mem::transmute(&bstr)).into()
            }
        }
        unsafe extern "system" fn GetDest<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pbstr: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEditTag_Impl::GetDest(this, core::mem::transmute_copy(&pbstr)).into()
            }
        }
        unsafe extern "system" fn SetDest<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            bstr: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEditTag_Impl::SetDest(this, core::mem::transmute(&bstr)).into()
            }
        }
        unsafe extern "system" fn OnPreSave<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEditTag_Impl::OnPreSave(this).into()
            }
        }
        unsafe extern "system" fn OnPostSave<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEditTag_Impl::OnPostSave(this).into()
            }
        }
        unsafe extern "system" fn CanPackage<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEditTag_Impl::CanPackage(this).into()
            }
        }
        unsafe extern "system" fn IsValidMimeType<
            Identity: IMimeEditTag_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            psztypew: windows_core::PCWSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEditTag_Impl::IsValidMimeType(this, core::mem::transmute(&psztypew)).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetSrc: GetSrc::<Identity, OFFSET>,
            SetSrc: SetSrc::<Identity, OFFSET>,
            GetDest: GetDest::<Identity, OFFSET>,
            SetDest: SetDest::<Identity, OFFSET>,
            OnPreSave: OnPreSave::<Identity, OFFSET>,
            OnPostSave: OnPostSave::<Identity, OFFSET>,
            CanPackage: CanPackage::<Identity, OFFSET>,
            IsValidMimeType: IsValidMimeType::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeEditTag as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeEditTag {}
windows_core::imp::define_interface!(
    IMimeEditTagCollection,
    IMimeEditTagCollection_Vtbl,
    0xd09ee528_7b38_11d2_8c12_00c04fa31009
);
windows_core::imp::interface_hierarchy!(IMimeEditTagCollection, windows_core::IUnknown);
impl IMimeEditTagCollection {
    pub unsafe fn Init<P0>(&self, phtmldoc: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::IUnknown>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Init)(
                windows_core::Interface::as_raw(self),
                phtmldoc.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn Next(
        &self,
        cfetch: u32,
        pptag: *mut Option<IMimeEditTag>,
        pcfetched: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Next)(
                windows_core::Interface::as_raw(self),
                cfetch,
                core::mem::transmute(pptag),
                pcfetched as _,
            )
            .ok()
        }
    }
    pub unsafe fn Reset(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Count)(
                windows_core::Interface::as_raw(self),
                pcitems as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeEditTagCollection_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Init: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Next: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub Count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMimeEditTagCollection_Impl: windows_core::IUnknownImpl {
    fn Init(
        &self,
        phtmldoc: windows_core::Ref<'_, windows_core::IUnknown>,
    ) -> windows_core::Result<()>;
    fn Next(
        &self,
        cfetch: u32,
        pptag: windows_core::OutRef<'_, IMimeEditTag>,
        pcfetched: *mut u32,
    ) -> windows_core::Result<()>;
    fn Reset(&self) -> windows_core::Result<()>;
    fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()>;
}
impl IMimeEditTagCollection_Vtbl {
    pub const fn new<Identity: IMimeEditTagCollection_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Init<
            Identity: IMimeEditTagCollection_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            phtmldoc: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEditTagCollection_Impl::Init(this, core::mem::transmute_copy(&phtmldoc)).into()
            }
        }
        unsafe extern "system" fn Next<
            Identity: IMimeEditTagCollection_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cfetch: u32,
            pptag: *mut *mut core::ffi::c_void,
            pcfetched: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEditTagCollection_Impl::Next(
                    this,
                    core::mem::transmute_copy(&cfetch),
                    core::mem::transmute_copy(&pptag),
                    core::mem::transmute_copy(&pcfetched),
                )
                .into()
            }
        }
        unsafe extern "system" fn Reset<
            Identity: IMimeEditTagCollection_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEditTagCollection_Impl::Reset(this).into()
            }
        }
        unsafe extern "system" fn Count<
            Identity: IMimeEditTagCollection_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pcitems: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEditTagCollection_Impl::Count(this, core::mem::transmute_copy(&pcitems)).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Init: Init::<Identity, OFFSET>,
            Next: Next::<Identity, OFFSET>,
            Reset: Reset::<Identity, OFFSET>,
            Count: Count::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeEditTagCollection as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeEditTagCollection {}
windows_core::imp::define_interface!(
    IMimeEnumAddressTypes,
    IMimeEnumAddressTypes_Vtbl,
    0xc5588354_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeEnumAddressTypes, windows_core::IUnknown);
impl IMimeEnumAddressTypes {
    pub unsafe fn Next(
        &self,
        cfetch: u32,
        prgadr: *mut ADDRESSPROPS,
        pcfetched: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Next)(
                windows_core::Interface::as_raw(self),
                cfetch,
                prgadr as _,
                pcfetched as _,
            )
            .ok()
        }
    }
    pub unsafe fn Skip(&self, citems: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Skip)(
                windows_core::Interface::as_raw(self),
                citems,
            )
            .ok()
        }
    }
    pub unsafe fn Reset(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn Clone(&self) -> windows_core::Result<IMimeEnumAddressTypes> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).Clone)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Count)(
                windows_core::Interface::as_raw(self),
                pcitems as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeEnumAddressTypes_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Next: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ADDRESSPROPS,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub Clone: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMimeEnumAddressTypes_Impl: windows_core::IUnknownImpl {
    fn Next(
        &self,
        cfetch: u32,
        prgadr: *mut ADDRESSPROPS,
        pcfetched: *mut u32,
    ) -> windows_core::Result<()>;
    fn Skip(&self, citems: u32) -> windows_core::Result<()>;
    fn Reset(&self) -> windows_core::Result<()>;
    fn Clone(&self) -> windows_core::Result<IMimeEnumAddressTypes>;
    fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()>;
}
impl IMimeEnumAddressTypes_Vtbl {
    pub const fn new<Identity: IMimeEnumAddressTypes_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Next<
            Identity: IMimeEnumAddressTypes_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cfetch: u32,
            prgadr: *mut ADDRESSPROPS,
            pcfetched: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumAddressTypes_Impl::Next(
                    this,
                    core::mem::transmute_copy(&cfetch),
                    core::mem::transmute_copy(&prgadr),
                    core::mem::transmute_copy(&pcfetched),
                )
                .into()
            }
        }
        unsafe extern "system" fn Skip<
            Identity: IMimeEnumAddressTypes_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            citems: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumAddressTypes_Impl::Skip(this, core::mem::transmute_copy(&citems)).into()
            }
        }
        unsafe extern "system" fn Reset<
            Identity: IMimeEnumAddressTypes_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumAddressTypes_Impl::Reset(this).into()
            }
        }
        unsafe extern "system" fn Clone<
            Identity: IMimeEnumAddressTypes_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ppenum: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeEnumAddressTypes_Impl::Clone(this) {
                    Ok(ok__) => {
                        ppenum.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn Count<
            Identity: IMimeEnumAddressTypes_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pcitems: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumAddressTypes_Impl::Count(this, core::mem::transmute_copy(&pcitems)).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Next: Next::<Identity, OFFSET>,
            Skip: Skip::<Identity, OFFSET>,
            Reset: Reset::<Identity, OFFSET>,
            Clone: Clone::<Identity, OFFSET>,
            Count: Count::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeEnumAddressTypes as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeEnumAddressTypes {}
windows_core::imp::define_interface!(
    IMimeEnumHeaderRows,
    IMimeEnumHeaderRows_Vtbl,
    0xc558834d_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeEnumHeaderRows, windows_core::IUnknown);
impl IMimeEnumHeaderRows {
    pub unsafe fn Next(
        &self,
        cfetch: u32,
        prgrow: *mut ENUMHEADERROW,
        pcfetched: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Next)(
                windows_core::Interface::as_raw(self),
                cfetch,
                prgrow as _,
                pcfetched as _,
            )
            .ok()
        }
    }
    pub unsafe fn Skip(&self, citems: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Skip)(
                windows_core::Interface::as_raw(self),
                citems,
            )
            .ok()
        }
    }
    pub unsafe fn Reset(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn Clone(&self) -> windows_core::Result<IMimeEnumHeaderRows> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).Clone)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Count)(
                windows_core::Interface::as_raw(self),
                pcitems as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeEnumHeaderRows_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Next: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENUMHEADERROW,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub Clone: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMimeEnumHeaderRows_Impl: windows_core::IUnknownImpl {
    fn Next(
        &self,
        cfetch: u32,
        prgrow: *mut ENUMHEADERROW,
        pcfetched: *mut u32,
    ) -> windows_core::Result<()>;
    fn Skip(&self, citems: u32) -> windows_core::Result<()>;
    fn Reset(&self) -> windows_core::Result<()>;
    fn Clone(&self) -> windows_core::Result<IMimeEnumHeaderRows>;
    fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()>;
}
impl IMimeEnumHeaderRows_Vtbl {
    pub const fn new<Identity: IMimeEnumHeaderRows_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Next<Identity: IMimeEnumHeaderRows_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cfetch: u32,
            prgrow: *mut ENUMHEADERROW,
            pcfetched: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumHeaderRows_Impl::Next(
                    this,
                    core::mem::transmute_copy(&cfetch),
                    core::mem::transmute_copy(&prgrow),
                    core::mem::transmute_copy(&pcfetched),
                )
                .into()
            }
        }
        unsafe extern "system" fn Skip<Identity: IMimeEnumHeaderRows_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            citems: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumHeaderRows_Impl::Skip(this, core::mem::transmute_copy(&citems)).into()
            }
        }
        unsafe extern "system" fn Reset<Identity: IMimeEnumHeaderRows_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumHeaderRows_Impl::Reset(this).into()
            }
        }
        unsafe extern "system" fn Clone<Identity: IMimeEnumHeaderRows_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ppenum: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeEnumHeaderRows_Impl::Clone(this) {
                    Ok(ok__) => {
                        ppenum.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn Count<Identity: IMimeEnumHeaderRows_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pcitems: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumHeaderRows_Impl::Count(this, core::mem::transmute_copy(&pcitems)).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Next: Next::<Identity, OFFSET>,
            Skip: Skip::<Identity, OFFSET>,
            Reset: Reset::<Identity, OFFSET>,
            Clone: Clone::<Identity, OFFSET>,
            Count: Count::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeEnumHeaderRows as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeEnumHeaderRows {}
windows_core::imp::define_interface!(
    IMimeEnumMessageParts,
    IMimeEnumMessageParts_Vtbl,
    0xc5588350_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeEnumMessageParts, windows_core::IUnknown);
impl IMimeEnumMessageParts {
    pub unsafe fn Next(
        &self,
        cfetch: u32,
        prgpmessage: *mut Option<IMimeMessage>,
        pcfetched: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Next)(
                windows_core::Interface::as_raw(self),
                cfetch,
                core::mem::transmute(prgpmessage),
                pcfetched as _,
            )
            .ok()
        }
    }
    pub unsafe fn Skip(&self, citems: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Skip)(
                windows_core::Interface::as_raw(self),
                citems,
            )
            .ok()
        }
    }
    pub unsafe fn Reset(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn Clone(&self) -> windows_core::Result<IMimeEnumMessageParts> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).Clone)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Count)(
                windows_core::Interface::as_raw(self),
                pcitems as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeEnumMessageParts_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Next: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub Clone: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMimeEnumMessageParts_Impl: windows_core::IUnknownImpl {
    fn Next(
        &self,
        cfetch: u32,
        prgpmessage: windows_core::OutRef<'_, IMimeMessage>,
        pcfetched: *mut u32,
    ) -> windows_core::Result<()>;
    fn Skip(&self, citems: u32) -> windows_core::Result<()>;
    fn Reset(&self) -> windows_core::Result<()>;
    fn Clone(&self) -> windows_core::Result<IMimeEnumMessageParts>;
    fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()>;
}
impl IMimeEnumMessageParts_Vtbl {
    pub const fn new<Identity: IMimeEnumMessageParts_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Next<
            Identity: IMimeEnumMessageParts_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cfetch: u32,
            prgpmessage: *mut *mut core::ffi::c_void,
            pcfetched: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumMessageParts_Impl::Next(
                    this,
                    core::mem::transmute_copy(&cfetch),
                    core::mem::transmute_copy(&prgpmessage),
                    core::mem::transmute_copy(&pcfetched),
                )
                .into()
            }
        }
        unsafe extern "system" fn Skip<
            Identity: IMimeEnumMessageParts_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            citems: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumMessageParts_Impl::Skip(this, core::mem::transmute_copy(&citems)).into()
            }
        }
        unsafe extern "system" fn Reset<
            Identity: IMimeEnumMessageParts_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumMessageParts_Impl::Reset(this).into()
            }
        }
        unsafe extern "system" fn Clone<
            Identity: IMimeEnumMessageParts_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ppenum: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeEnumMessageParts_Impl::Clone(this) {
                    Ok(ok__) => {
                        ppenum.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn Count<
            Identity: IMimeEnumMessageParts_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pcitems: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumMessageParts_Impl::Count(this, core::mem::transmute_copy(&pcitems)).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Next: Next::<Identity, OFFSET>,
            Skip: Skip::<Identity, OFFSET>,
            Reset: Reset::<Identity, OFFSET>,
            Clone: Clone::<Identity, OFFSET>,
            Count: Count::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeEnumMessageParts as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeEnumMessageParts {}
windows_core::imp::define_interface!(
    IMimeEnumProperties,
    IMimeEnumProperties_Vtbl,
    0xfd853cee_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeEnumProperties, windows_core::IUnknown);
impl IMimeEnumProperties {
    pub unsafe fn Next(
        &self,
        cfetch: u32,
        prgprop: *mut ENUMPROPERTY,
        pcfetched: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Next)(
                windows_core::Interface::as_raw(self),
                cfetch,
                prgprop as _,
                pcfetched as _,
            )
            .ok()
        }
    }
    pub unsafe fn Skip(&self, citems: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Skip)(
                windows_core::Interface::as_raw(self),
                citems,
            )
            .ok()
        }
    }
    pub unsafe fn Reset(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn Clone(&self) -> windows_core::Result<IMimeEnumProperties> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).Clone)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Count)(
                windows_core::Interface::as_raw(self),
                pcitems as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeEnumProperties_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Next: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENUMPROPERTY,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub Clone: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMimeEnumProperties_Impl: windows_core::IUnknownImpl {
    fn Next(
        &self,
        cfetch: u32,
        prgprop: *mut ENUMPROPERTY,
        pcfetched: *mut u32,
    ) -> windows_core::Result<()>;
    fn Skip(&self, citems: u32) -> windows_core::Result<()>;
    fn Reset(&self) -> windows_core::Result<()>;
    fn Clone(&self) -> windows_core::Result<IMimeEnumProperties>;
    fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()>;
}
impl IMimeEnumProperties_Vtbl {
    pub const fn new<Identity: IMimeEnumProperties_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Next<Identity: IMimeEnumProperties_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cfetch: u32,
            prgprop: *mut ENUMPROPERTY,
            pcfetched: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumProperties_Impl::Next(
                    this,
                    core::mem::transmute_copy(&cfetch),
                    core::mem::transmute_copy(&prgprop),
                    core::mem::transmute_copy(&pcfetched),
                )
                .into()
            }
        }
        unsafe extern "system" fn Skip<Identity: IMimeEnumProperties_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            citems: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumProperties_Impl::Skip(this, core::mem::transmute_copy(&citems)).into()
            }
        }
        unsafe extern "system" fn Reset<Identity: IMimeEnumProperties_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumProperties_Impl::Reset(this).into()
            }
        }
        unsafe extern "system" fn Clone<Identity: IMimeEnumProperties_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ppenum: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeEnumProperties_Impl::Clone(this) {
                    Ok(ok__) => {
                        ppenum.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn Count<Identity: IMimeEnumProperties_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pcitems: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeEnumProperties_Impl::Count(this, core::mem::transmute_copy(&pcitems)).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Next: Next::<Identity, OFFSET>,
            Skip: Skip::<Identity, OFFSET>,
            Reset: Reset::<Identity, OFFSET>,
            Clone: Clone::<Identity, OFFSET>,
            Count: Count::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeEnumProperties as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeEnumProperties {}
windows_core::imp::define_interface!(
    IMimeHeaderTable,
    IMimeHeaderTable_Vtbl,
    0xfd853cd1_7f86_11d0_8252_00c04fd85ab4
);
impl core::ops::Deref for IMimeHeaderTable {
    type Target = windows::Win32::System::Com::IPersistStream;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IMimeHeaderTable,
    windows_core::IUnknown,
    windows::Win32::System::Com::IPersist,
    windows::Win32::System::Com::IPersistStream
);
impl IMimeHeaderTable {
    pub unsafe fn Load<P0>(&self, pstm: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Load)(
                windows_core::Interface::as_raw(self),
                pstm.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn Save<P0>(&self, pstm: P0, fcleardirty: bool) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Save)(
                windows_core::Interface::as_raw(self),
                pstm.param().abi(),
                fcleardirty.into(),
            )
            .ok()
        }
    }
    pub unsafe fn GetSizeMax(&self) -> windows_core::Result<u64> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetSizeMax)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .map(|| result__)
        }
    }
    pub unsafe fn FindFirstRow(
        &self,
        pfindheader: *mut FINDHEADER,
        phrow: *mut *mut HHEADERROW__,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FindFirstRow)(
                windows_core::Interface::as_raw(self),
                pfindheader as _,
                phrow as _,
            )
            .ok()
        }
    }
    pub unsafe fn FindNextRow(
        &self,
        pfindheader: *mut FINDHEADER,
        phrow: *mut *mut HHEADERROW__,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FindNextRow)(
                windows_core::Interface::as_raw(self),
                pfindheader as _,
                phrow as _,
            )
            .ok()
        }
    }
    pub unsafe fn CountRows<P0>(&self, pszheader: P0, pcrows: *mut u32) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CountRows)(
                windows_core::Interface::as_raw(self),
                pszheader.param().abi(),
                pcrows as _,
            )
            .ok()
        }
    }
    pub unsafe fn AppendRow<P0, P2>(
        &self,
        pszheader: P0,
        dwflags: u32,
        pszdata: P2,
        cchdata: u32,
        phrow: *mut *mut HHEADERROW__,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
        P2: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).AppendRow)(
                windows_core::Interface::as_raw(self),
                pszheader.param().abi(),
                dwflags,
                pszdata.param().abi(),
                cchdata,
                phrow as _,
            )
            .ok()
        }
    }
    pub unsafe fn DeleteRow(&self, hrow: *mut HHEADERROW__) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteRow)(
                windows_core::Interface::as_raw(self),
                hrow as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetRowData(
        &self,
        hrow: *mut HHEADERROW__,
        dwflags: u32,
        ppszdata: *mut windows_core::PSTR,
        pcchdata: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetRowData)(
                windows_core::Interface::as_raw(self),
                hrow as _,
                dwflags,
                ppszdata as _,
                pcchdata as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetRowData<P2>(
        &self,
        hrow: *mut HHEADERROW__,
        dwflags: u32,
        pszdata: P2,
        cchdata: u32,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SetRowData)(
                windows_core::Interface::as_raw(self),
                hrow as _,
                dwflags,
                pszdata.param().abi(),
                cchdata,
            )
            .ok()
        }
    }
    pub unsafe fn GetRowInfo(
        &self,
        hrow: *mut HHEADERROW__,
        pinfo: *mut HEADERROWINFO,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetRowInfo)(
                windows_core::Interface::as_raw(self),
                hrow as _,
                pinfo as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetRowNumber(
        &self,
        hrow: *mut HHEADERROW__,
        dwrownumber: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetRowNumber)(
                windows_core::Interface::as_raw(self),
                hrow as _,
                dwrownumber,
            )
            .ok()
        }
    }
    pub unsafe fn EnumRows<P0>(
        &self,
        pszheader: P0,
        dwflags: u32,
    ) -> windows_core::Result<IMimeEnumHeaderRows>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).EnumRows)(
                windows_core::Interface::as_raw(self),
                pszheader.param().abi(),
                dwflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn Clone(&self) -> windows_core::Result<IMimeHeaderTable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).Clone)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn BindToObject(
        &self,
        riid: *const windows_core::GUID,
        ppvobject: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).BindToObject)(
                windows_core::Interface::as_raw(self),
                riid,
                ppvobject as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeHeaderTable_Vtbl {
    pub base__: windows::Win32::System::Com::IPersistStream_Vtbl,
    pub Load: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Save: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        windows_core::BOOL,
    ) -> windows_core::HRESULT,
    pub GetSizeMax:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
    pub FindFirstRow: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut FINDHEADER,
        *mut *mut HHEADERROW__,
    ) -> windows_core::HRESULT,
    pub FindNextRow: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut FINDHEADER,
        *mut *mut HHEADERROW__,
    ) -> windows_core::HRESULT,
    pub CountRows: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub AppendRow: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        u32,
        windows_core::PCSTR,
        u32,
        *mut *mut HHEADERROW__,
    ) -> windows_core::HRESULT,
    pub DeleteRow: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HHEADERROW__,
    ) -> windows_core::HRESULT,
    pub GetRowData: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HHEADERROW__,
        u32,
        *mut windows_core::PSTR,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub SetRowData: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HHEADERROW__,
        u32,
        windows_core::PCSTR,
        u32,
    ) -> windows_core::HRESULT,
    pub GetRowInfo: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HHEADERROW__,
        *mut HEADERROWINFO,
    ) -> windows_core::HRESULT,
    pub SetRowNumber: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HHEADERROW__,
        u32,
    ) -> windows_core::HRESULT,
    pub EnumRows: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Clone: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub BindToObject: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *const windows_core::GUID,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMimeHeaderTable_Impl: windows::Win32::System::Com::IPersistStream_Impl {
    fn Load(
        &self,
        pstm: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()>;
    fn Save(
        &self,
        pstm: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        fcleardirty: windows_core::BOOL,
    ) -> windows_core::Result<()>;
    fn GetSizeMax(&self) -> windows_core::Result<u64>;
    fn FindFirstRow(
        &self,
        pfindheader: *mut FINDHEADER,
        phrow: *mut *mut HHEADERROW__,
    ) -> windows_core::Result<()>;
    fn FindNextRow(
        &self,
        pfindheader: *mut FINDHEADER,
        phrow: *mut *mut HHEADERROW__,
    ) -> windows_core::Result<()>;
    fn CountRows(
        &self,
        pszheader: &windows_core::PCSTR,
        pcrows: *mut u32,
    ) -> windows_core::Result<()>;
    fn AppendRow(
        &self,
        pszheader: &windows_core::PCSTR,
        dwflags: u32,
        pszdata: &windows_core::PCSTR,
        cchdata: u32,
        phrow: *mut *mut HHEADERROW__,
    ) -> windows_core::Result<()>;
    fn DeleteRow(&self, hrow: *mut HHEADERROW__) -> windows_core::Result<()>;
    fn GetRowData(
        &self,
        hrow: *mut HHEADERROW__,
        dwflags: u32,
        ppszdata: *mut windows_core::PSTR,
        pcchdata: *mut u32,
    ) -> windows_core::Result<()>;
    fn SetRowData(
        &self,
        hrow: *mut HHEADERROW__,
        dwflags: u32,
        pszdata: &windows_core::PCSTR,
        cchdata: u32,
    ) -> windows_core::Result<()>;
    fn GetRowInfo(
        &self,
        hrow: *mut HHEADERROW__,
        pinfo: *mut HEADERROWINFO,
    ) -> windows_core::Result<()>;
    fn SetRowNumber(&self, hrow: *mut HHEADERROW__, dwrownumber: u32) -> windows_core::Result<()>;
    fn EnumRows(
        &self,
        pszheader: &windows_core::PCSTR,
        dwflags: u32,
    ) -> windows_core::Result<IMimeEnumHeaderRows>;
    fn Clone(&self) -> windows_core::Result<IMimeHeaderTable>;
    fn BindToObject(
        &self,
        riid: *const windows_core::GUID,
        ppvobject: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()>;
}
impl IMimeHeaderTable_Vtbl {
    pub const fn new<Identity: IMimeHeaderTable_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Load<Identity: IMimeHeaderTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pstm: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeHeaderTable_Impl::Load(this, core::mem::transmute_copy(&pstm)).into()
            }
        }
        unsafe extern "system" fn Save<Identity: IMimeHeaderTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pstm: *mut core::ffi::c_void,
            fcleardirty: windows_core::BOOL,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeHeaderTable_Impl::Save(
                    this,
                    core::mem::transmute_copy(&pstm),
                    core::mem::transmute_copy(&fcleardirty),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetSizeMax<
            Identity: IMimeHeaderTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pcbsize: *mut u64,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeHeaderTable_Impl::GetSizeMax(this) {
                    Ok(ok__) => {
                        pcbsize.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn FindFirstRow<
            Identity: IMimeHeaderTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pfindheader: *mut FINDHEADER,
            phrow: *mut *mut HHEADERROW__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeHeaderTable_Impl::FindFirstRow(
                    this,
                    core::mem::transmute_copy(&pfindheader),
                    core::mem::transmute_copy(&phrow),
                )
                .into()
            }
        }
        unsafe extern "system" fn FindNextRow<
            Identity: IMimeHeaderTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pfindheader: *mut FINDHEADER,
            phrow: *mut *mut HHEADERROW__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeHeaderTable_Impl::FindNextRow(
                    this,
                    core::mem::transmute_copy(&pfindheader),
                    core::mem::transmute_copy(&phrow),
                )
                .into()
            }
        }
        unsafe extern "system" fn CountRows<
            Identity: IMimeHeaderTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszheader: windows_core::PCSTR,
            pcrows: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeHeaderTable_Impl::CountRows(
                    this,
                    core::mem::transmute(&pszheader),
                    core::mem::transmute_copy(&pcrows),
                )
                .into()
            }
        }
        unsafe extern "system" fn AppendRow<
            Identity: IMimeHeaderTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszheader: windows_core::PCSTR,
            dwflags: u32,
            pszdata: windows_core::PCSTR,
            cchdata: u32,
            phrow: *mut *mut HHEADERROW__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeHeaderTable_Impl::AppendRow(
                    this,
                    core::mem::transmute(&pszheader),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute(&pszdata),
                    core::mem::transmute_copy(&cchdata),
                    core::mem::transmute_copy(&phrow),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteRow<
            Identity: IMimeHeaderTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hrow: *mut HHEADERROW__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeHeaderTable_Impl::DeleteRow(this, core::mem::transmute_copy(&hrow)).into()
            }
        }
        unsafe extern "system" fn GetRowData<
            Identity: IMimeHeaderTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hrow: *mut HHEADERROW__,
            dwflags: u32,
            ppszdata: *mut windows_core::PSTR,
            pcchdata: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeHeaderTable_Impl::GetRowData(
                    this,
                    core::mem::transmute_copy(&hrow),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute_copy(&ppszdata),
                    core::mem::transmute_copy(&pcchdata),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetRowData<
            Identity: IMimeHeaderTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hrow: *mut HHEADERROW__,
            dwflags: u32,
            pszdata: windows_core::PCSTR,
            cchdata: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeHeaderTable_Impl::SetRowData(
                    this,
                    core::mem::transmute_copy(&hrow),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute(&pszdata),
                    core::mem::transmute_copy(&cchdata),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetRowInfo<
            Identity: IMimeHeaderTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hrow: *mut HHEADERROW__,
            pinfo: *mut HEADERROWINFO,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeHeaderTable_Impl::GetRowInfo(
                    this,
                    core::mem::transmute_copy(&hrow),
                    core::mem::transmute_copy(&pinfo),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetRowNumber<
            Identity: IMimeHeaderTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hrow: *mut HHEADERROW__,
            dwrownumber: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeHeaderTable_Impl::SetRowNumber(
                    this,
                    core::mem::transmute_copy(&hrow),
                    core::mem::transmute_copy(&dwrownumber),
                )
                .into()
            }
        }
        unsafe extern "system" fn EnumRows<Identity: IMimeHeaderTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pszheader: windows_core::PCSTR,
            dwflags: u32,
            ppenum: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeHeaderTable_Impl::EnumRows(
                    this,
                    core::mem::transmute(&pszheader),
                    core::mem::transmute_copy(&dwflags),
                ) {
                    Ok(ok__) => {
                        ppenum.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn Clone<Identity: IMimeHeaderTable_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeHeaderTable_Impl::Clone(this) {
                    Ok(ok__) => {
                        pptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn BindToObject<
            Identity: IMimeHeaderTable_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            riid: *const windows_core::GUID,
            ppvobject: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeHeaderTable_Impl::BindToObject(
                    this,
                    core::mem::transmute_copy(&riid),
                    core::mem::transmute_copy(&ppvobject),
                )
                .into()
            }
        }
        Self {
            base__: windows::Win32::System::Com::IPersistStream_Vtbl::new::<Identity, OFFSET>(),
            Load: Load::<Identity, OFFSET>,
            Save: Save::<Identity, OFFSET>,
            GetSizeMax: GetSizeMax::<Identity, OFFSET>,
            FindFirstRow: FindFirstRow::<Identity, OFFSET>,
            FindNextRow: FindNextRow::<Identity, OFFSET>,
            CountRows: CountRows::<Identity, OFFSET>,
            AppendRow: AppendRow::<Identity, OFFSET>,
            DeleteRow: DeleteRow::<Identity, OFFSET>,
            GetRowData: GetRowData::<Identity, OFFSET>,
            SetRowData: SetRowData::<Identity, OFFSET>,
            GetRowInfo: GetRowInfo::<Identity, OFFSET>,
            SetRowNumber: SetRowNumber::<Identity, OFFSET>,
            EnumRows: EnumRows::<Identity, OFFSET>,
            Clone: Clone::<Identity, OFFSET>,
            BindToObject: BindToObject::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeHeaderTable as windows_core::Interface>::IID
            || iid == &<windows::Win32::System::Com::IPersist as windows_core::Interface>::IID
            || iid == &<windows::Win32::System::Com::IPersistStream as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeHeaderTable {}
windows_core::imp::define_interface!(
    IMimeInternational,
    IMimeInternational_Vtbl,
    0xc5588349_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeInternational, windows_core::IUnknown);
impl IMimeInternational {
    pub unsafe fn SetDefaultCharset(&self, hcharset: *mut HCHARSET__) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetDefaultCharset)(
                windows_core::Interface::as_raw(self),
                hcharset as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetDefaultCharset(
        &self,
        phcharset: *mut *mut HCHARSET__,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetDefaultCharset)(
                windows_core::Interface::as_raw(self),
                phcharset as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetCodePageCharset(
        &self,
        cpicodepage: u32,
        ctcsettype: CHARSETTYPE,
        phcharset: *mut *mut HCHARSET__,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetCodePageCharset)(
                windows_core::Interface::as_raw(self),
                cpicodepage,
                ctcsettype,
                phcharset as _,
            )
            .ok()
        }
    }
    pub unsafe fn FindCharset<P0>(
        &self,
        pszcharset: P0,
        phcharset: *mut *mut HCHARSET__,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).FindCharset)(
                windows_core::Interface::as_raw(self),
                pszcharset.param().abi(),
                phcharset as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetCharsetInfo(
        &self,
        hcharset: *mut HCHARSET__,
        pcsetinfo: *mut INETCSETINFO,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetCharsetInfo)(
                windows_core::Interface::as_raw(self),
                hcharset as _,
                pcsetinfo as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetCodePageInfo(
        &self,
        cpicodepage: u32,
        pcodepageinfo: *mut CODEPAGEINFO,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetCodePageInfo)(
                windows_core::Interface::as_raw(self),
                cpicodepage,
                pcodepageinfo as _,
            )
            .ok()
        }
    }
    pub unsafe fn CanConvertCodePages(
        &self,
        cpisource: u32,
        cpidest: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CanConvertCodePages)(
                windows_core::Interface::as_raw(self),
                cpisource,
                cpidest,
            )
            .ok()
        }
    }
    pub unsafe fn DecodeHeader<P1>(
        &self,
        hcharset: *mut HCHARSET__,
        pszdata: P1,
        pdecoded: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        prfc1522info: *mut RFC1522INFO,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DecodeHeader)(
                windows_core::Interface::as_raw(self),
                hcharset as _,
                pszdata.param().abi(),
                core::mem::transmute(pdecoded),
                prfc1522info as _,
            )
            .ok()
        }
    }
    pub unsafe fn EncodeHeader(
        &self,
        hcharset: *mut HCHARSET__,
        pdata: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ppszencoded: *mut windows_core::PSTR,
        prfc1522info: *mut RFC1522INFO,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).EncodeHeader)(
                windows_core::Interface::as_raw(self),
                hcharset as _,
                core::mem::transmute(pdata),
                ppszencoded as _,
                prfc1522info as _,
            )
            .ok()
        }
    }
    pub unsafe fn ConvertBuffer(
        &self,
        cpisource: u32,
        cpidest: u32,
        pin: *mut windows::Win32::System::Com::BLOB,
        pout: *mut windows::Win32::System::Com::BLOB,
        pcbread: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ConvertBuffer)(
                windows_core::Interface::as_raw(self),
                cpisource,
                cpidest,
                pin as _,
                pout as _,
                pcbread as _,
            )
            .ok()
        }
    }
    pub unsafe fn ConvertString(
        &self,
        cpisource: u32,
        cpidest: u32,
        pin: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        pout: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ConvertString)(
                windows_core::Interface::as_raw(self),
                cpisource,
                cpidest,
                core::mem::transmute(pin),
                core::mem::transmute(pout),
            )
            .ok()
        }
    }
    pub unsafe fn MLANG_ConvertInetReset(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).MLANG_ConvertInetReset)(
                windows_core::Interface::as_raw(self),
            )
            .ok()
        }
    }
    pub unsafe fn MLANG_ConvertInetString<P2, P4>(
        &self,
        cpisource: u32,
        cpidest: u32,
        psource: P2,
        pnsizeofsource: *mut i32,
        pdestination: P4,
        pndstsize: *mut i32,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<windows_core::PCSTR>,
        P4: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).MLANG_ConvertInetString)(
                windows_core::Interface::as_raw(self),
                cpisource,
                cpidest,
                psource.param().abi(),
                pnsizeofsource as _,
                pdestination.param().abi(),
                pndstsize as _,
            )
            .ok()
        }
    }
    pub unsafe fn Rfc1522Decode<P0, P1>(
        &self,
        pszvalue: P0,
        pszcharset: P1,
        cchmax: u32,
        ppszdecoded: *mut windows_core::PSTR,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Rfc1522Decode)(
                windows_core::Interface::as_raw(self),
                pszvalue.param().abi(),
                pszcharset.param().abi(),
                cchmax,
                ppszdecoded as _,
            )
            .ok()
        }
    }
    pub unsafe fn Rfc1522Encode<P0>(
        &self,
        pszvalue: P0,
        hcharset: *mut HCHARSET__,
        ppszencoded: *mut windows_core::PSTR,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Rfc1522Encode)(
                windows_core::Interface::as_raw(self),
                pszvalue.param().abi(),
                hcharset as _,
                ppszencoded as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeInternational_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub SetDefaultCharset:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut HCHARSET__) -> windows_core::HRESULT,
    pub GetDefaultCharset: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut HCHARSET__,
    ) -> windows_core::HRESULT,
    pub GetCodePageCharset: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        CHARSETTYPE,
        *mut *mut HCHARSET__,
    ) -> windows_core::HRESULT,
    pub FindCharset: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut *mut HCHARSET__,
    ) -> windows_core::HRESULT,
    pub GetCharsetInfo: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HCHARSET__,
        *mut INETCSETINFO,
    ) -> windows_core::HRESULT,
    pub GetCodePageInfo: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut CODEPAGEINFO,
    ) -> windows_core::HRESULT,
    pub CanConvertCodePages:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32) -> windows_core::HRESULT,
    pub DecodeHeader: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HCHARSET__,
        windows_core::PCSTR,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        *mut RFC1522INFO,
    ) -> windows_core::HRESULT,
    pub EncodeHeader: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HCHARSET__,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        *mut windows_core::PSTR,
        *mut RFC1522INFO,
    ) -> windows_core::HRESULT,
    pub ConvertBuffer: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut windows::Win32::System::Com::BLOB,
        *mut windows::Win32::System::Com::BLOB,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub ConvertString: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
    pub MLANG_ConvertInetReset:
        unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub MLANG_ConvertInetString: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        windows_core::PCSTR,
        *mut i32,
        windows_core::PCSTR,
        *mut i32,
    ) -> windows_core::HRESULT,
    pub Rfc1522Decode: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        windows_core::PCSTR,
        u32,
        *mut windows_core::PSTR,
    ) -> windows_core::HRESULT,
    pub Rfc1522Encode: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut HCHARSET__,
        *mut windows_core::PSTR,
    ) -> windows_core::HRESULT,
}
pub trait IMimeInternational_Impl: windows_core::IUnknownImpl {
    fn SetDefaultCharset(&self, hcharset: *mut HCHARSET__) -> windows_core::Result<()>;
    fn GetDefaultCharset(&self, phcharset: *mut *mut HCHARSET__) -> windows_core::Result<()>;
    fn GetCodePageCharset(
        &self,
        cpicodepage: u32,
        ctcsettype: CHARSETTYPE,
        phcharset: *mut *mut HCHARSET__,
    ) -> windows_core::Result<()>;
    fn FindCharset(
        &self,
        pszcharset: &windows_core::PCSTR,
        phcharset: *mut *mut HCHARSET__,
    ) -> windows_core::Result<()>;
    fn GetCharsetInfo(
        &self,
        hcharset: *mut HCHARSET__,
        pcsetinfo: *mut INETCSETINFO,
    ) -> windows_core::Result<()>;
    fn GetCodePageInfo(
        &self,
        cpicodepage: u32,
        pcodepageinfo: *mut CODEPAGEINFO,
    ) -> windows_core::Result<()>;
    fn CanConvertCodePages(&self, cpisource: u32, cpidest: u32) -> windows_core::Result<()>;
    fn DecodeHeader(
        &self,
        hcharset: *mut HCHARSET__,
        pszdata: &windows_core::PCSTR,
        pdecoded: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        prfc1522info: *mut RFC1522INFO,
    ) -> windows_core::Result<()>;
    fn EncodeHeader(
        &self,
        hcharset: *mut HCHARSET__,
        pdata: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ppszencoded: *mut windows_core::PSTR,
        prfc1522info: *mut RFC1522INFO,
    ) -> windows_core::Result<()>;
    fn ConvertBuffer(
        &self,
        cpisource: u32,
        cpidest: u32,
        pin: *mut windows::Win32::System::Com::BLOB,
        pout: *mut windows::Win32::System::Com::BLOB,
        pcbread: *mut u32,
    ) -> windows_core::Result<()>;
    fn ConvertString(
        &self,
        cpisource: u32,
        cpidest: u32,
        pin: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        pout: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
    fn MLANG_ConvertInetReset(&self) -> windows_core::Result<()>;
    fn MLANG_ConvertInetString(
        &self,
        cpisource: u32,
        cpidest: u32,
        psource: &windows_core::PCSTR,
        pnsizeofsource: *mut i32,
        pdestination: &windows_core::PCSTR,
        pndstsize: *mut i32,
    ) -> windows_core::Result<()>;
    fn Rfc1522Decode(
        &self,
        pszvalue: &windows_core::PCSTR,
        pszcharset: &windows_core::PCSTR,
        cchmax: u32,
        ppszdecoded: *mut windows_core::PSTR,
    ) -> windows_core::Result<()>;
    fn Rfc1522Encode(
        &self,
        pszvalue: &windows_core::PCSTR,
        hcharset: *mut HCHARSET__,
        ppszencoded: *mut windows_core::PSTR,
    ) -> windows_core::Result<()>;
}
impl IMimeInternational_Vtbl {
    pub const fn new<Identity: IMimeInternational_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn SetDefaultCharset<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hcharset: *mut HCHARSET__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::SetDefaultCharset(
                    this,
                    core::mem::transmute_copy(&hcharset),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetDefaultCharset<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            phcharset: *mut *mut HCHARSET__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::GetDefaultCharset(
                    this,
                    core::mem::transmute_copy(&phcharset),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetCodePageCharset<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cpicodepage: u32,
            ctcsettype: CHARSETTYPE,
            phcharset: *mut *mut HCHARSET__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::GetCodePageCharset(
                    this,
                    core::mem::transmute_copy(&cpicodepage),
                    core::mem::transmute_copy(&ctcsettype),
                    core::mem::transmute_copy(&phcharset),
                )
                .into()
            }
        }
        unsafe extern "system" fn FindCharset<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszcharset: windows_core::PCSTR,
            phcharset: *mut *mut HCHARSET__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::FindCharset(
                    this,
                    core::mem::transmute(&pszcharset),
                    core::mem::transmute_copy(&phcharset),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetCharsetInfo<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hcharset: *mut HCHARSET__,
            pcsetinfo: *mut INETCSETINFO,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::GetCharsetInfo(
                    this,
                    core::mem::transmute_copy(&hcharset),
                    core::mem::transmute_copy(&pcsetinfo),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetCodePageInfo<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cpicodepage: u32,
            pcodepageinfo: *mut CODEPAGEINFO,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::GetCodePageInfo(
                    this,
                    core::mem::transmute_copy(&cpicodepage),
                    core::mem::transmute_copy(&pcodepageinfo),
                )
                .into()
            }
        }
        unsafe extern "system" fn CanConvertCodePages<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cpisource: u32,
            cpidest: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::CanConvertCodePages(
                    this,
                    core::mem::transmute_copy(&cpisource),
                    core::mem::transmute_copy(&cpidest),
                )
                .into()
            }
        }
        unsafe extern "system" fn DecodeHeader<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hcharset: *mut HCHARSET__,
            pszdata: windows_core::PCSTR,
            pdecoded: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
            prfc1522info: *mut RFC1522INFO,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::DecodeHeader(
                    this,
                    core::mem::transmute_copy(&hcharset),
                    core::mem::transmute(&pszdata),
                    core::mem::transmute_copy(&pdecoded),
                    core::mem::transmute_copy(&prfc1522info),
                )
                .into()
            }
        }
        unsafe extern "system" fn EncodeHeader<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hcharset: *mut HCHARSET__,
            pdata: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
            ppszencoded: *mut windows_core::PSTR,
            prfc1522info: *mut RFC1522INFO,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::EncodeHeader(
                    this,
                    core::mem::transmute_copy(&hcharset),
                    core::mem::transmute_copy(&pdata),
                    core::mem::transmute_copy(&ppszencoded),
                    core::mem::transmute_copy(&prfc1522info),
                )
                .into()
            }
        }
        unsafe extern "system" fn ConvertBuffer<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cpisource: u32,
            cpidest: u32,
            pin: *mut windows::Win32::System::Com::BLOB,
            pout: *mut windows::Win32::System::Com::BLOB,
            pcbread: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::ConvertBuffer(
                    this,
                    core::mem::transmute_copy(&cpisource),
                    core::mem::transmute_copy(&cpidest),
                    core::mem::transmute_copy(&pin),
                    core::mem::transmute_copy(&pout),
                    core::mem::transmute_copy(&pcbread),
                )
                .into()
            }
        }
        unsafe extern "system" fn ConvertString<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cpisource: u32,
            cpidest: u32,
            pin: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
            pout: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::ConvertString(
                    this,
                    core::mem::transmute_copy(&cpisource),
                    core::mem::transmute_copy(&cpidest),
                    core::mem::transmute_copy(&pin),
                    core::mem::transmute_copy(&pout),
                )
                .into()
            }
        }
        unsafe extern "system" fn MLANG_ConvertInetReset<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::MLANG_ConvertInetReset(this).into()
            }
        }
        unsafe extern "system" fn MLANG_ConvertInetString<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cpisource: u32,
            cpidest: u32,
            psource: windows_core::PCSTR,
            pnsizeofsource: *mut i32,
            pdestination: windows_core::PCSTR,
            pndstsize: *mut i32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::MLANG_ConvertInetString(
                    this,
                    core::mem::transmute_copy(&cpisource),
                    core::mem::transmute_copy(&cpidest),
                    core::mem::transmute(&psource),
                    core::mem::transmute_copy(&pnsizeofsource),
                    core::mem::transmute(&pdestination),
                    core::mem::transmute_copy(&pndstsize),
                )
                .into()
            }
        }
        unsafe extern "system" fn Rfc1522Decode<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszvalue: windows_core::PCSTR,
            pszcharset: windows_core::PCSTR,
            cchmax: u32,
            ppszdecoded: *mut windows_core::PSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::Rfc1522Decode(
                    this,
                    core::mem::transmute(&pszvalue),
                    core::mem::transmute(&pszcharset),
                    core::mem::transmute_copy(&cchmax),
                    core::mem::transmute_copy(&ppszdecoded),
                )
                .into()
            }
        }
        unsafe extern "system" fn Rfc1522Encode<
            Identity: IMimeInternational_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszvalue: windows_core::PCSTR,
            hcharset: *mut HCHARSET__,
            ppszencoded: *mut windows_core::PSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeInternational_Impl::Rfc1522Encode(
                    this,
                    core::mem::transmute(&pszvalue),
                    core::mem::transmute_copy(&hcharset),
                    core::mem::transmute_copy(&ppszencoded),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            SetDefaultCharset: SetDefaultCharset::<Identity, OFFSET>,
            GetDefaultCharset: GetDefaultCharset::<Identity, OFFSET>,
            GetCodePageCharset: GetCodePageCharset::<Identity, OFFSET>,
            FindCharset: FindCharset::<Identity, OFFSET>,
            GetCharsetInfo: GetCharsetInfo::<Identity, OFFSET>,
            GetCodePageInfo: GetCodePageInfo::<Identity, OFFSET>,
            CanConvertCodePages: CanConvertCodePages::<Identity, OFFSET>,
            DecodeHeader: DecodeHeader::<Identity, OFFSET>,
            EncodeHeader: EncodeHeader::<Identity, OFFSET>,
            ConvertBuffer: ConvertBuffer::<Identity, OFFSET>,
            ConvertString: ConvertString::<Identity, OFFSET>,
            MLANG_ConvertInetReset: MLANG_ConvertInetReset::<Identity, OFFSET>,
            MLANG_ConvertInetString: MLANG_ConvertInetString::<Identity, OFFSET>,
            Rfc1522Decode: Rfc1522Decode::<Identity, OFFSET>,
            Rfc1522Encode: Rfc1522Encode::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeInternational as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeInternational {}
windows_core::imp::define_interface!(
    IMimeMessage,
    IMimeMessage_Vtbl,
    0xfd853cd5_7f86_11d0_8252_00c04fd85ab4
);
impl core::ops::Deref for IMimeMessage {
    type Target = IMimeMessageTree;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IMimeMessage,
    windows_core::IUnknown,
    windows::Win32::System::Com::IPersist,
    windows::Win32::System::Com::IPersistStreamInit,
    IMimeMessageTree
);
impl IMimeMessage {
    pub unsafe fn CreateWebPage<P0, P2>(
        &self,
        prootstm: P0,
        poptions: *mut WEBPAGEOPTIONS,
        pcallback: P2,
        ppmoniker: *mut Option<windows::Win32::System::Com::IMoniker>,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
        P2: windows_core::Param<IMimeMessageCallback>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CreateWebPage)(
                windows_core::Interface::as_raw(self),
                prootstm.param().abi(),
                poptions as _,
                pcallback.param().abi(),
                core::mem::transmute(ppmoniker),
            )
            .ok()
        }
    }
    pub unsafe fn GetPropA<P0>(
        &self,
        pszname: P0,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetPropA)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                dwflags,
                core::mem::transmute(pvalue),
            )
            .ok()
        }
    }
    pub unsafe fn SetPropA<P0>(
        &self,
        pszname: P0,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SetPropA)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                dwflags,
                core::mem::transmute(pvalue),
            )
            .ok()
        }
    }
    pub unsafe fn DeleteProp<P0>(&self, pszname: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteProp)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn QueryProp<P0, P1>(
        &self,
        pszname: P0,
        pszcriteria: P1,
        fsubstring: u8,
        fcasesensitive: u8,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).QueryProp)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                pszcriteria.param().abi(),
                fsubstring,
                fcasesensitive,
            )
            .ok()
        }
    }
    pub unsafe fn GetTextBody(
        &self,
        dwtxttype: u32,
        ietencoding: ENCODINGTYPE,
        ppstream: *mut Option<windows::Win32::System::Com::IStream>,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetTextBody)(
                windows_core::Interface::as_raw(self),
                dwtxttype,
                ietencoding,
                core::mem::transmute(ppstream),
                phbody as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetTextBody<P3>(
        &self,
        dwtxttype: u32,
        ietencoding: ENCODINGTYPE,
        halternative: *mut HBODY__,
        pstream: P3,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SetTextBody)(
                windows_core::Interface::as_raw(self),
                dwtxttype,
                ietencoding,
                halternative as _,
                pstream.param().abi(),
                phbody as _,
            )
            .ok()
        }
    }
    pub unsafe fn AttachObject(
        &self,
        riid: *const windows_core::GUID,
        pvobject: *mut core::ffi::c_void,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).AttachObject)(
                windows_core::Interface::as_raw(self),
                riid,
                pvobject as _,
                phbody as _,
            )
            .ok()
        }
    }
    pub unsafe fn AttachFile<P0, P1>(
        &self,
        pszfilepath: P0,
        pstmfile: P1,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
        P1: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).AttachFile)(
                windows_core::Interface::as_raw(self),
                pszfilepath.param().abi(),
                pstmfile.param().abi(),
                phbody as _,
            )
            .ok()
        }
    }
    pub unsafe fn AttachURL<P0, P1, P3>(
        &self,
        pszbase: P0,
        pszurl: P1,
        dwflags: u32,
        pstmurl: P3,
        ppszcidurl: *mut windows_core::PSTR,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
        P1: windows_core::Param<windows_core::PCSTR>,
        P3: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).AttachURL)(
                windows_core::Interface::as_raw(self),
                pszbase.param().abi(),
                pszurl.param().abi(),
                dwflags,
                pstmurl.param().abi(),
                ppszcidurl as _,
                phbody as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetAttachments(
        &self,
        pcattach: *mut u32,
        pprghattach: *mut *mut *mut HBODY__,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetAttachments)(
                windows_core::Interface::as_raw(self),
                pcattach as _,
                pprghattach as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetAddressTable(&self) -> windows_core::Result<IMimeAddressTable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetAddressTable)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn GetSender(&self, paddress: *mut ADDRESSPROPS) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetSender)(
                windows_core::Interface::as_raw(self),
                paddress as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetAddressTypes(
        &self,
        dwadrtypes: u32,
        dwprops: u32,
        plist: *mut ADDRESSLIST,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetAddressTypes)(
                windows_core::Interface::as_raw(self),
                dwadrtypes,
                dwprops,
                plist as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetAddressFormat(
        &self,
        dwadrtype: u32,
        format: ADDRESSFORMAT,
        ppszformat: *mut windows_core::PSTR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetAddressFormat)(
                windows_core::Interface::as_raw(self),
                dwadrtype,
                format,
                ppszformat as _,
            )
            .ok()
        }
    }
    pub unsafe fn EnumAddressTypes(
        &self,
        dwadrtypes: u32,
        dwprops: u32,
    ) -> windows_core::Result<IMimeEnumAddressTypes> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).EnumAddressTypes)(
                windows_core::Interface::as_raw(self),
                dwadrtypes,
                dwprops,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn SplitMessage(&self, cbmaxpart: u32) -> windows_core::Result<IMimeMessageParts> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).SplitMessage)(
                windows_core::Interface::as_raw(self),
                cbmaxpart,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn GetRootMoniker(
        &self,
    ) -> windows_core::Result<windows::Win32::System::Com::IMoniker> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetRootMoniker)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
}
#[repr(C)]
pub struct IMimeMessage_Vtbl {
    pub base__: IMimeMessageTree_Vtbl,
    pub CreateWebPage: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut WEBPAGEOPTIONS,
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetPropA: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        u32,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
    pub SetPropA: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        u32,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
    pub DeleteProp: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
    ) -> windows_core::HRESULT,
    pub QueryProp: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        windows_core::PCSTR,
        u8,
        u8,
    ) -> windows_core::HRESULT,
    pub GetTextBody: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        ENCODINGTYPE,
        *mut *mut core::ffi::c_void,
        *mut *mut HBODY__,
    ) -> windows_core::HRESULT,
    pub SetTextBody: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        ENCODINGTYPE,
        *mut HBODY__,
        *mut core::ffi::c_void,
        *mut *mut HBODY__,
    ) -> windows_core::HRESULT,
    pub AttachObject: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *const windows_core::GUID,
        *mut core::ffi::c_void,
        *mut *mut HBODY__,
    ) -> windows_core::HRESULT,
    pub AttachFile: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut core::ffi::c_void,
        *mut *mut HBODY__,
    ) -> windows_core::HRESULT,
    pub AttachURL: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        windows_core::PCSTR,
        u32,
        *mut core::ffi::c_void,
        *mut windows_core::PSTR,
        *mut *mut HBODY__,
    ) -> windows_core::HRESULT,
    pub GetAttachments: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut u32,
        *mut *mut *mut HBODY__,
    ) -> windows_core::HRESULT,
    pub GetAddressTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetSender: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut ADDRESSPROPS,
    ) -> windows_core::HRESULT,
    pub GetAddressTypes: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut ADDRESSLIST,
    ) -> windows_core::HRESULT,
    pub GetAddressFormat: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        ADDRESSFORMAT,
        *mut windows_core::PSTR,
    ) -> windows_core::HRESULT,
    pub EnumAddressTypes: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SplitMessage: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetRootMoniker: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMimeMessage_Impl: IMimeMessageTree_Impl {
    fn CreateWebPage(
        &self,
        prootstm: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        poptions: *mut WEBPAGEOPTIONS,
        pcallback: windows_core::Ref<'_, IMimeMessageCallback>,
        ppmoniker: windows_core::OutRef<'_, windows::Win32::System::Com::IMoniker>,
    ) -> windows_core::Result<()>;
    fn GetPropA(
        &self,
        pszname: &windows_core::PCSTR,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
    fn SetPropA(
        &self,
        pszname: &windows_core::PCSTR,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
    fn DeleteProp(&self, pszname: &windows_core::PCSTR) -> windows_core::Result<()>;
    fn QueryProp(
        &self,
        pszname: &windows_core::PCSTR,
        pszcriteria: &windows_core::PCSTR,
        fsubstring: u8,
        fcasesensitive: u8,
    ) -> windows_core::Result<()>;
    fn GetTextBody(
        &self,
        dwtxttype: u32,
        ietencoding: ENCODINGTYPE,
        ppstream: windows_core::OutRef<'_, windows::Win32::System::Com::IStream>,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>;
    fn SetTextBody(
        &self,
        dwtxttype: u32,
        ietencoding: ENCODINGTYPE,
        halternative: *mut HBODY__,
        pstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>;
    fn AttachObject(
        &self,
        riid: *const windows_core::GUID,
        pvobject: *mut core::ffi::c_void,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>;
    fn AttachFile(
        &self,
        pszfilepath: &windows_core::PCSTR,
        pstmfile: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>;
    fn AttachURL(
        &self,
        pszbase: &windows_core::PCSTR,
        pszurl: &windows_core::PCSTR,
        dwflags: u32,
        pstmurl: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        ppszcidurl: *mut windows_core::PSTR,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>;
    fn GetAttachments(
        &self,
        pcattach: *mut u32,
        pprghattach: *mut *mut *mut HBODY__,
    ) -> windows_core::Result<()>;
    fn GetAddressTable(&self) -> windows_core::Result<IMimeAddressTable>;
    fn GetSender(&self, paddress: *mut ADDRESSPROPS) -> windows_core::Result<()>;
    fn GetAddressTypes(
        &self,
        dwadrtypes: u32,
        dwprops: u32,
        plist: *mut ADDRESSLIST,
    ) -> windows_core::Result<()>;
    fn GetAddressFormat(
        &self,
        dwadrtype: u32,
        format: ADDRESSFORMAT,
        ppszformat: *mut windows_core::PSTR,
    ) -> windows_core::Result<()>;
    fn EnumAddressTypes(
        &self,
        dwadrtypes: u32,
        dwprops: u32,
    ) -> windows_core::Result<IMimeEnumAddressTypes>;
    fn SplitMessage(&self, cbmaxpart: u32) -> windows_core::Result<IMimeMessageParts>;
    fn GetRootMoniker(&self) -> windows_core::Result<windows::Win32::System::Com::IMoniker>;
}
impl IMimeMessage_Vtbl {
    pub const fn new<Identity: IMimeMessage_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn CreateWebPage<
            Identity: IMimeMessage_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            prootstm: *mut core::ffi::c_void,
            poptions: *mut WEBPAGEOPTIONS,
            pcallback: *mut core::ffi::c_void,
            ppmoniker: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::CreateWebPage(
                    this,
                    core::mem::transmute_copy(&prootstm),
                    core::mem::transmute_copy(&poptions),
                    core::mem::transmute_copy(&pcallback),
                    core::mem::transmute_copy(&ppmoniker),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetPropA<Identity: IMimeMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            dwflags: u32,
            pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::GetPropA(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute_copy(&pvalue),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetPropA<Identity: IMimeMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            dwflags: u32,
            pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::SetPropA(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute_copy(&pvalue),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteProp<Identity: IMimeMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::DeleteProp(this, core::mem::transmute(&pszname)).into()
            }
        }
        unsafe extern "system" fn QueryProp<Identity: IMimeMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            pszcriteria: windows_core::PCSTR,
            fsubstring: u8,
            fcasesensitive: u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::QueryProp(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute(&pszcriteria),
                    core::mem::transmute_copy(&fsubstring),
                    core::mem::transmute_copy(&fcasesensitive),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetTextBody<Identity: IMimeMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            dwtxttype: u32,
            ietencoding: ENCODINGTYPE,
            ppstream: *mut *mut core::ffi::c_void,
            phbody: *mut *mut HBODY__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::GetTextBody(
                    this,
                    core::mem::transmute_copy(&dwtxttype),
                    core::mem::transmute_copy(&ietencoding),
                    core::mem::transmute_copy(&ppstream),
                    core::mem::transmute_copy(&phbody),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetTextBody<Identity: IMimeMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            dwtxttype: u32,
            ietencoding: ENCODINGTYPE,
            halternative: *mut HBODY__,
            pstream: *mut core::ffi::c_void,
            phbody: *mut *mut HBODY__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::SetTextBody(
                    this,
                    core::mem::transmute_copy(&dwtxttype),
                    core::mem::transmute_copy(&ietencoding),
                    core::mem::transmute_copy(&halternative),
                    core::mem::transmute_copy(&pstream),
                    core::mem::transmute_copy(&phbody),
                )
                .into()
            }
        }
        unsafe extern "system" fn AttachObject<Identity: IMimeMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            riid: *const windows_core::GUID,
            pvobject: *mut core::ffi::c_void,
            phbody: *mut *mut HBODY__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::AttachObject(
                    this,
                    core::mem::transmute_copy(&riid),
                    core::mem::transmute_copy(&pvobject),
                    core::mem::transmute_copy(&phbody),
                )
                .into()
            }
        }
        unsafe extern "system" fn AttachFile<Identity: IMimeMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pszfilepath: windows_core::PCSTR,
            pstmfile: *mut core::ffi::c_void,
            phbody: *mut *mut HBODY__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::AttachFile(
                    this,
                    core::mem::transmute(&pszfilepath),
                    core::mem::transmute_copy(&pstmfile),
                    core::mem::transmute_copy(&phbody),
                )
                .into()
            }
        }
        unsafe extern "system" fn AttachURL<Identity: IMimeMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pszbase: windows_core::PCSTR,
            pszurl: windows_core::PCSTR,
            dwflags: u32,
            pstmurl: *mut core::ffi::c_void,
            ppszcidurl: *mut windows_core::PSTR,
            phbody: *mut *mut HBODY__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::AttachURL(
                    this,
                    core::mem::transmute(&pszbase),
                    core::mem::transmute(&pszurl),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute_copy(&pstmurl),
                    core::mem::transmute_copy(&ppszcidurl),
                    core::mem::transmute_copy(&phbody),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetAttachments<
            Identity: IMimeMessage_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pcattach: *mut u32,
            pprghattach: *mut *mut *mut HBODY__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::GetAttachments(
                    this,
                    core::mem::transmute_copy(&pcattach),
                    core::mem::transmute_copy(&pprghattach),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetAddressTable<
            Identity: IMimeMessage_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeMessage_Impl::GetAddressTable(this) {
                    Ok(ok__) => {
                        pptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn GetSender<Identity: IMimeMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            paddress: *mut ADDRESSPROPS,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::GetSender(this, core::mem::transmute_copy(&paddress)).into()
            }
        }
        unsafe extern "system" fn GetAddressTypes<
            Identity: IMimeMessage_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwadrtypes: u32,
            dwprops: u32,
            plist: *mut ADDRESSLIST,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::GetAddressTypes(
                    this,
                    core::mem::transmute_copy(&dwadrtypes),
                    core::mem::transmute_copy(&dwprops),
                    core::mem::transmute_copy(&plist),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetAddressFormat<
            Identity: IMimeMessage_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwadrtype: u32,
            format: ADDRESSFORMAT,
            ppszformat: *mut windows_core::PSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessage_Impl::GetAddressFormat(
                    this,
                    core::mem::transmute_copy(&dwadrtype),
                    core::mem::transmute_copy(&format),
                    core::mem::transmute_copy(&ppszformat),
                )
                .into()
            }
        }
        unsafe extern "system" fn EnumAddressTypes<
            Identity: IMimeMessage_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwadrtypes: u32,
            dwprops: u32,
            ppenum: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeMessage_Impl::EnumAddressTypes(
                    this,
                    core::mem::transmute_copy(&dwadrtypes),
                    core::mem::transmute_copy(&dwprops),
                ) {
                    Ok(ok__) => {
                        ppenum.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn SplitMessage<Identity: IMimeMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbmaxpart: u32,
            ppparts: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeMessage_Impl::SplitMessage(this, core::mem::transmute_copy(&cbmaxpart)) {
                    Ok(ok__) => {
                        ppparts.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn GetRootMoniker<
            Identity: IMimeMessage_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ppmoniker: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeMessage_Impl::GetRootMoniker(this) {
                    Ok(ok__) => {
                        ppmoniker.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: IMimeMessageTree_Vtbl::new::<Identity, OFFSET>(),
            CreateWebPage: CreateWebPage::<Identity, OFFSET>,
            GetPropA: GetPropA::<Identity, OFFSET>,
            SetPropA: SetPropA::<Identity, OFFSET>,
            DeleteProp: DeleteProp::<Identity, OFFSET>,
            QueryProp: QueryProp::<Identity, OFFSET>,
            GetTextBody: GetTextBody::<Identity, OFFSET>,
            SetTextBody: SetTextBody::<Identity, OFFSET>,
            AttachObject: AttachObject::<Identity, OFFSET>,
            AttachFile: AttachFile::<Identity, OFFSET>,
            AttachURL: AttachURL::<Identity, OFFSET>,
            GetAttachments: GetAttachments::<Identity, OFFSET>,
            GetAddressTable: GetAddressTable::<Identity, OFFSET>,
            GetSender: GetSender::<Identity, OFFSET>,
            GetAddressTypes: GetAddressTypes::<Identity, OFFSET>,
            GetAddressFormat: GetAddressFormat::<Identity, OFFSET>,
            EnumAddressTypes: EnumAddressTypes::<Identity, OFFSET>,
            SplitMessage: SplitMessage::<Identity, OFFSET>,
            GetRootMoniker: GetRootMoniker::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == & < IMimeMessage as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersist as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersistStreamInit as windows_core::Interface >::IID || iid == & < IMimeMessageTree as windows_core::Interface >::IID
    }
}
impl windows_core::RuntimeName for IMimeMessage {}
windows_core::imp::define_interface!(
    IMimeMessageCallback,
    IMimeMessageCallback_Vtbl,
    0x761aa641_7bda_11d1_8aa9_00c04fb951f3
);
windows_core::imp::interface_hierarchy!(IMimeMessageCallback, windows_core::IUnknown);
impl IMimeMessageCallback {
    pub unsafe fn OnWebPageSplitter<P1>(
        &self,
        cinlined: u32,
        ppstream: P1,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).OnWebPageSplitter)(
                windows_core::Interface::as_raw(self),
                cinlined,
                ppstream.param().abi(),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeMessageCallback_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub OnWebPageSplitter: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMimeMessageCallback_Impl: windows_core::IUnknownImpl {
    fn OnWebPageSplitter(
        &self,
        cinlined: u32,
        ppstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()>;
}
impl IMimeMessageCallback_Vtbl {
    pub const fn new<Identity: IMimeMessageCallback_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn OnWebPageSplitter<
            Identity: IMimeMessageCallback_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cinlined: u32,
            ppstream: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageCallback_Impl::OnWebPageSplitter(
                    this,
                    core::mem::transmute_copy(&cinlined),
                    core::mem::transmute_copy(&ppstream),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            OnWebPageSplitter: OnWebPageSplitter::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeMessageCallback as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeMessageCallback {}
windows_core::imp::define_interface!(
    IMimeMessageParts,
    IMimeMessageParts_Vtbl,
    0xc558834f_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeMessageParts, windows_core::IUnknown);
impl IMimeMessageParts {
    pub unsafe fn CombineParts(&self) -> windows_core::Result<IMimeMessage> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).CombineParts)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn AddPart<P0>(&self, pmessage: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMimeMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).AddPart)(
                windows_core::Interface::as_raw(self),
                pmessage.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn SetMaxParts(&self, cparts: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetMaxParts)(
                windows_core::Interface::as_raw(self),
                cparts,
            )
            .ok()
        }
    }
    pub unsafe fn CountParts(&self, pcparts: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CountParts)(
                windows_core::Interface::as_raw(self),
                pcparts as _,
            )
            .ok()
        }
    }
    pub unsafe fn EnumParts(&self) -> windows_core::Result<IMimeEnumMessageParts> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).EnumParts)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
}
#[repr(C)]
pub struct IMimeMessageParts_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub CombineParts: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub AddPart: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SetMaxParts:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub CountParts:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub EnumParts: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMimeMessageParts_Impl: windows_core::IUnknownImpl {
    fn CombineParts(&self) -> windows_core::Result<IMimeMessage>;
    fn AddPart(&self, pmessage: windows_core::Ref<'_, IMimeMessage>) -> windows_core::Result<()>;
    fn SetMaxParts(&self, cparts: u32) -> windows_core::Result<()>;
    fn CountParts(&self, pcparts: *mut u32) -> windows_core::Result<()>;
    fn EnumParts(&self) -> windows_core::Result<IMimeEnumMessageParts>;
}
impl IMimeMessageParts_Vtbl {
    pub const fn new<Identity: IMimeMessageParts_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn CombineParts<
            Identity: IMimeMessageParts_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ppmessage: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeMessageParts_Impl::CombineParts(this) {
                    Ok(ok__) => {
                        ppmessage.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn AddPart<Identity: IMimeMessageParts_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pmessage: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageParts_Impl::AddPart(this, core::mem::transmute_copy(&pmessage)).into()
            }
        }
        unsafe extern "system" fn SetMaxParts<
            Identity: IMimeMessageParts_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cparts: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageParts_Impl::SetMaxParts(this, core::mem::transmute_copy(&cparts)).into()
            }
        }
        unsafe extern "system" fn CountParts<
            Identity: IMimeMessageParts_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pcparts: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageParts_Impl::CountParts(this, core::mem::transmute_copy(&pcparts)).into()
            }
        }
        unsafe extern "system" fn EnumParts<
            Identity: IMimeMessageParts_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ppenum: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeMessageParts_Impl::EnumParts(this) {
                    Ok(ok__) => {
                        ppenum.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            CombineParts: CombineParts::<Identity, OFFSET>,
            AddPart: AddPart::<Identity, OFFSET>,
            SetMaxParts: SetMaxParts::<Identity, OFFSET>,
            CountParts: CountParts::<Identity, OFFSET>,
            EnumParts: EnumParts::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeMessageParts as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeMessageParts {}
windows_core::imp::define_interface!(
    IMimeMessageTree,
    IMimeMessageTree_Vtbl,
    0xfd853cd4_7f86_11d0_8252_00c04fd85ab4
);
impl core::ops::Deref for IMimeMessageTree {
    type Target = windows::Win32::System::Com::IPersistStreamInit;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IMimeMessageTree,
    windows_core::IUnknown,
    windows::Win32::System::Com::IPersist,
    windows::Win32::System::Com::IPersistStreamInit
);
impl IMimeMessageTree {
    pub unsafe fn Save<P0>(&self, pstm: P0, fcleardirty: bool) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Save)(
                windows_core::Interface::as_raw(self),
                pstm.param().abi(),
                fcleardirty.into(),
            )
            .ok()
        }
    }
    pub unsafe fn GetSizeMax(&self) -> windows_core::Result<u64> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetSizeMax)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .map(|| result__)
        }
    }
    pub unsafe fn InitNew(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).InitNew)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn GetMessageSource(
        &self,
        ppstream: *mut Option<windows::Win32::System::Com::IStream>,
        dwflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetMessageSource)(
                windows_core::Interface::as_raw(self),
                core::mem::transmute(ppstream),
                dwflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetMessageSize(
        &self,
        pcbsize: *mut u32,
        dwflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetMessageSize)(
                windows_core::Interface::as_raw(self),
                pcbsize as _,
                dwflags,
            )
            .ok()
        }
    }
    pub unsafe fn LoadOffsetTable<P0>(&self, pstream: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).LoadOffsetTable)(
                windows_core::Interface::as_raw(self),
                pstream.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn SaveOffsetTable<P0>(&self, pstream: P0, dwflags: u32) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SaveOffsetTable)(
                windows_core::Interface::as_raw(self),
                pstream.param().abi(),
                dwflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetFlags(&self, pdwflags: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetFlags)(
                windows_core::Interface::as_raw(self),
                pdwflags as _,
            )
            .ok()
        }
    }
    pub unsafe fn Commit(&self, dwflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Commit)(
                windows_core::Interface::as_raw(self),
                dwflags,
            )
            .ok()
        }
    }
    pub unsafe fn HandsOffStorage(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HandsOffStorage)(
                windows_core::Interface::as_raw(self),
            )
            .ok()
        }
    }
    pub unsafe fn BindToObject(
        &self,
        hbody: *const HBODY__,
        riid: *const windows_core::GUID,
        ppvobject: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).BindToObject)(
                windows_core::Interface::as_raw(self),
                hbody,
                riid,
                ppvobject as _,
            )
            .ok()
        }
    }
    pub unsafe fn SaveBody<P2>(
        &self,
        hbody: *mut HBODY__,
        dwflags: u32,
        pstream: P2,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SaveBody)(
                windows_core::Interface::as_raw(self),
                hbody as _,
                dwflags,
                pstream.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn InsertBody(
        &self,
        location: BODYLOCATION,
        hpivot: *mut HBODY__,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).InsertBody)(
                windows_core::Interface::as_raw(self),
                location,
                hpivot as _,
                phbody as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetBody(
        &self,
        location: BODYLOCATION,
        hpivot: *mut HBODY__,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetBody)(
                windows_core::Interface::as_raw(self),
                location,
                hpivot as _,
                phbody as _,
            )
            .ok()
        }
    }
    pub unsafe fn DeleteBody(&self, hbody: *mut HBODY__, dwflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteBody)(
                windows_core::Interface::as_raw(self),
                hbody as _,
                dwflags,
            )
            .ok()
        }
    }
    pub unsafe fn MoveBody(
        &self,
        hbody: *mut HBODY__,
        location: BODYLOCATION,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).MoveBody)(
                windows_core::Interface::as_raw(self),
                hbody as _,
                location,
            )
            .ok()
        }
    }
    pub unsafe fn CountBodies(
        &self,
        hparent: *mut HBODY__,
        frecurse: u8,
        pcbodies: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CountBodies)(
                windows_core::Interface::as_raw(self),
                hparent as _,
                frecurse,
                pcbodies as _,
            )
            .ok()
        }
    }
    pub unsafe fn FindFirst(
        &self,
        pfindbody: *mut FINDBODY,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FindFirst)(
                windows_core::Interface::as_raw(self),
                pfindbody as _,
                phbody as _,
            )
            .ok()
        }
    }
    pub unsafe fn FindNext(
        &self,
        pfindbody: *mut FINDBODY,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FindNext)(
                windows_core::Interface::as_raw(self),
                pfindbody as _,
                phbody as _,
            )
            .ok()
        }
    }
    pub unsafe fn ResolveURL<P1, P2>(
        &self,
        hrelated: *mut HBODY__,
        pszbase: P1,
        pszurl: P2,
        dwflags: u32,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows_core::PCSTR>,
        P2: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).ResolveURL)(
                windows_core::Interface::as_raw(self),
                hrelated as _,
                pszbase.param().abi(),
                pszurl.param().abi(),
                dwflags,
                phbody as _,
            )
            .ok()
        }
    }
    pub unsafe fn ToMultipart<P1>(
        &self,
        hbody: *mut HBODY__,
        pszsubtype: P1,
        phmultipart: *mut *mut HBODY__,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).ToMultipart)(
                windows_core::Interface::as_raw(self),
                hbody as _,
                pszsubtype.param().abi(),
                phmultipart as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetBodyOffsets(
        &self,
        hbody: *mut HBODY__,
        poffsets: *mut BODYOFFSETS,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetBodyOffsets)(
                windows_core::Interface::as_raw(self),
                hbody as _,
                poffsets as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetCharset(&self, phcharset: *mut *mut HCHARSET__) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetCharset)(
                windows_core::Interface::as_raw(self),
                phcharset as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetCharset(
        &self,
        hcharset: *mut HCHARSET__,
        applytype: CSETAPPLYTYPE,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetCharset)(
                windows_core::Interface::as_raw(self),
                hcharset as _,
                applytype,
            )
            .ok()
        }
    }
    pub unsafe fn IsBodyType(
        &self,
        hbody: *mut HBODY__,
        bodytype: IMSGBODYTYPE,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).IsBodyType)(
                windows_core::Interface::as_raw(self),
                hbody as _,
                bodytype,
            )
            .ok()
        }
    }
    pub unsafe fn IsContentType<P1, P2>(
        &self,
        hbody: *mut HBODY__,
        pszpritype: P1,
        pszsubtype: P2,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows_core::PCSTR>,
        P2: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).IsContentType)(
                windows_core::Interface::as_raw(self),
                hbody as _,
                pszpritype.param().abi(),
                pszsubtype.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn QueryBodyProp<P1, P2>(
        &self,
        hbody: *mut HBODY__,
        pszname: P1,
        pszcriteria: P2,
        fsubstring: u8,
        fcasesensitive: u8,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows_core::PCSTR>,
        P2: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).QueryBodyProp)(
                windows_core::Interface::as_raw(self),
                hbody as _,
                pszname.param().abi(),
                pszcriteria.param().abi(),
                fsubstring,
                fcasesensitive,
            )
            .ok()
        }
    }
    pub unsafe fn GetBodyProp<P1>(
        &self,
        hbody: *mut HBODY__,
        pszname: P1,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetBodyProp)(
                windows_core::Interface::as_raw(self),
                hbody as _,
                pszname.param().abi(),
                dwflags,
                core::mem::transmute(pvalue),
            )
            .ok()
        }
    }
    pub unsafe fn SetBodyProp<P1>(
        &self,
        hbody: *mut HBODY__,
        pszname: P1,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SetBodyProp)(
                windows_core::Interface::as_raw(self),
                hbody as _,
                pszname.param().abi(),
                dwflags,
                core::mem::transmute(pvalue),
            )
            .ok()
        }
    }
    pub unsafe fn DeleteBodyProp<P1>(
        &self,
        hbody: *mut HBODY__,
        pszname: P1,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteBodyProp)(
                windows_core::Interface::as_raw(self),
                hbody as _,
                pszname.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn SetOption(
        &self,
        oid: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetOption)(
                windows_core::Interface::as_raw(self),
                oid,
                core::mem::transmute(pvalue),
            )
            .ok()
        }
    }
    pub unsafe fn GetOption(
        &self,
        oid: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetOption)(
                windows_core::Interface::as_raw(self),
                oid,
                core::mem::transmute(pvalue),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeMessageTree_Vtbl {
    pub base__: windows::Win32::System::Com::IPersistStreamInit_Vtbl,
    pub Save: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        windows_core::BOOL,
    ) -> windows_core::HRESULT,
    pub GetSizeMax:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
    pub InitNew: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub GetMessageSource: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub GetMessageSize:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32, u32) -> windows_core::HRESULT,
    pub LoadOffsetTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SaveOffsetTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub GetFlags:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub Commit: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub HandsOffStorage: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub BindToObject: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *const HBODY__,
        *const windows_core::GUID,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SaveBody: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HBODY__,
        u32,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub InsertBody: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        BODYLOCATION,
        *mut HBODY__,
        *mut *mut HBODY__,
    ) -> windows_core::HRESULT,
    pub GetBody: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        BODYLOCATION,
        *mut HBODY__,
        *mut *mut HBODY__,
    ) -> windows_core::HRESULT,
    pub DeleteBody: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HBODY__,
        u32,
    ) -> windows_core::HRESULT,
    pub MoveBody: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HBODY__,
        BODYLOCATION,
    ) -> windows_core::HRESULT,
    pub CountBodies: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HBODY__,
        u8,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub FindFirst: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut FINDBODY,
        *mut *mut HBODY__,
    ) -> windows_core::HRESULT,
    pub FindNext: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut FINDBODY,
        *mut *mut HBODY__,
    ) -> windows_core::HRESULT,
    pub ResolveURL: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HBODY__,
        windows_core::PCSTR,
        windows_core::PCSTR,
        u32,
        *mut *mut HBODY__,
    ) -> windows_core::HRESULT,
    pub ToMultipart: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HBODY__,
        windows_core::PCSTR,
        *mut *mut HBODY__,
    ) -> windows_core::HRESULT,
    pub GetBodyOffsets: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HBODY__,
        *mut BODYOFFSETS,
    ) -> windows_core::HRESULT,
    pub GetCharset: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut HCHARSET__,
    ) -> windows_core::HRESULT,
    pub SetCharset: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HCHARSET__,
        CSETAPPLYTYPE,
    ) -> windows_core::HRESULT,
    pub IsBodyType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HBODY__,
        IMSGBODYTYPE,
    ) -> windows_core::HRESULT,
    pub IsContentType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HBODY__,
        windows_core::PCSTR,
        windows_core::PCSTR,
    ) -> windows_core::HRESULT,
    pub QueryBodyProp: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HBODY__,
        windows_core::PCSTR,
        windows_core::PCSTR,
        u8,
        u8,
    ) -> windows_core::HRESULT,
    pub GetBodyProp: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HBODY__,
        windows_core::PCSTR,
        u32,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
    pub SetBodyProp: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HBODY__,
        windows_core::PCSTR,
        u32,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
    pub DeleteBodyProp: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HBODY__,
        windows_core::PCSTR,
    ) -> windows_core::HRESULT,
    pub SetOption: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
    pub GetOption: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
}
pub trait IMimeMessageTree_Impl: windows::Win32::System::Com::IPersistStreamInit_Impl {
    fn Save(
        &self,
        pstm: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        fcleardirty: windows_core::BOOL,
    ) -> windows_core::Result<()>;
    fn GetSizeMax(&self) -> windows_core::Result<u64>;
    fn InitNew(&self) -> windows_core::Result<()>;
    fn GetMessageSource(
        &self,
        ppstream: windows_core::OutRef<'_, windows::Win32::System::Com::IStream>,
        dwflags: u32,
    ) -> windows_core::Result<()>;
    fn GetMessageSize(&self, pcbsize: *mut u32, dwflags: u32) -> windows_core::Result<()>;
    fn LoadOffsetTable(
        &self,
        pstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()>;
    fn SaveOffsetTable(
        &self,
        pstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        dwflags: u32,
    ) -> windows_core::Result<()>;
    fn GetFlags(&self, pdwflags: *mut u32) -> windows_core::Result<()>;
    fn Commit(&self, dwflags: u32) -> windows_core::Result<()>;
    fn HandsOffStorage(&self) -> windows_core::Result<()>;
    fn BindToObject(
        &self,
        hbody: *const HBODY__,
        riid: *const windows_core::GUID,
        ppvobject: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()>;
    fn SaveBody(
        &self,
        hbody: *mut HBODY__,
        dwflags: u32,
        pstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
    ) -> windows_core::Result<()>;
    fn InsertBody(
        &self,
        location: BODYLOCATION,
        hpivot: *mut HBODY__,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>;
    fn GetBody(
        &self,
        location: BODYLOCATION,
        hpivot: *mut HBODY__,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>;
    fn DeleteBody(&self, hbody: *mut HBODY__, dwflags: u32) -> windows_core::Result<()>;
    fn MoveBody(&self, hbody: *mut HBODY__, location: BODYLOCATION) -> windows_core::Result<()>;
    fn CountBodies(
        &self,
        hparent: *mut HBODY__,
        frecurse: u8,
        pcbodies: *mut u32,
    ) -> windows_core::Result<()>;
    fn FindFirst(
        &self,
        pfindbody: *mut FINDBODY,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>;
    fn FindNext(
        &self,
        pfindbody: *mut FINDBODY,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>;
    fn ResolveURL(
        &self,
        hrelated: *mut HBODY__,
        pszbase: &windows_core::PCSTR,
        pszurl: &windows_core::PCSTR,
        dwflags: u32,
        phbody: *mut *mut HBODY__,
    ) -> windows_core::Result<()>;
    fn ToMultipart(
        &self,
        hbody: *mut HBODY__,
        pszsubtype: &windows_core::PCSTR,
        phmultipart: *mut *mut HBODY__,
    ) -> windows_core::Result<()>;
    fn GetBodyOffsets(
        &self,
        hbody: *mut HBODY__,
        poffsets: *mut BODYOFFSETS,
    ) -> windows_core::Result<()>;
    fn GetCharset(&self, phcharset: *mut *mut HCHARSET__) -> windows_core::Result<()>;
    fn SetCharset(
        &self,
        hcharset: *mut HCHARSET__,
        applytype: CSETAPPLYTYPE,
    ) -> windows_core::Result<()>;
    fn IsBodyType(&self, hbody: *mut HBODY__, bodytype: IMSGBODYTYPE) -> windows_core::Result<()>;
    fn IsContentType(
        &self,
        hbody: *mut HBODY__,
        pszpritype: &windows_core::PCSTR,
        pszsubtype: &windows_core::PCSTR,
    ) -> windows_core::Result<()>;
    fn QueryBodyProp(
        &self,
        hbody: *mut HBODY__,
        pszname: &windows_core::PCSTR,
        pszcriteria: &windows_core::PCSTR,
        fsubstring: u8,
        fcasesensitive: u8,
    ) -> windows_core::Result<()>;
    fn GetBodyProp(
        &self,
        hbody: *mut HBODY__,
        pszname: &windows_core::PCSTR,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
    fn SetBodyProp(
        &self,
        hbody: *mut HBODY__,
        pszname: &windows_core::PCSTR,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
    fn DeleteBodyProp(
        &self,
        hbody: *mut HBODY__,
        pszname: &windows_core::PCSTR,
    ) -> windows_core::Result<()>;
    fn SetOption(
        &self,
        oid: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
    fn GetOption(
        &self,
        oid: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
}
impl IMimeMessageTree_Vtbl {
    pub const fn new<Identity: IMimeMessageTree_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Save<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pstm: *mut core::ffi::c_void,
            fcleardirty: windows_core::BOOL,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::Save(
                    this,
                    core::mem::transmute_copy(&pstm),
                    core::mem::transmute_copy(&fcleardirty),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetSizeMax<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pcbsize: *mut u64,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimeMessageTree_Impl::GetSizeMax(this) {
                    Ok(ok__) => {
                        pcbsize.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn InitNew<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::InitNew(this).into()
            }
        }
        unsafe extern "system" fn GetMessageSource<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ppstream: *mut *mut core::ffi::c_void,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::GetMessageSource(
                    this,
                    core::mem::transmute_copy(&ppstream),
                    core::mem::transmute_copy(&dwflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMessageSize<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pcbsize: *mut u32,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::GetMessageSize(
                    this,
                    core::mem::transmute_copy(&pcbsize),
                    core::mem::transmute_copy(&dwflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn LoadOffsetTable<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pstream: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::LoadOffsetTable(this, core::mem::transmute_copy(&pstream))
                    .into()
            }
        }
        unsafe extern "system" fn SaveOffsetTable<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pstream: *mut core::ffi::c_void,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::SaveOffsetTable(
                    this,
                    core::mem::transmute_copy(&pstream),
                    core::mem::transmute_copy(&dwflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetFlags<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pdwflags: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::GetFlags(this, core::mem::transmute_copy(&pdwflags)).into()
            }
        }
        unsafe extern "system" fn Commit<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::Commit(this, core::mem::transmute_copy(&dwflags)).into()
            }
        }
        unsafe extern "system" fn HandsOffStorage<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::HandsOffStorage(this).into()
            }
        }
        unsafe extern "system" fn BindToObject<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hbody: *const HBODY__,
            riid: *const windows_core::GUID,
            ppvobject: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::BindToObject(
                    this,
                    core::mem::transmute_copy(&hbody),
                    core::mem::transmute_copy(&riid),
                    core::mem::transmute_copy(&ppvobject),
                )
                .into()
            }
        }
        unsafe extern "system" fn SaveBody<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            hbody: *mut HBODY__,
            dwflags: u32,
            pstream: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::SaveBody(
                    this,
                    core::mem::transmute_copy(&hbody),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute_copy(&pstream),
                )
                .into()
            }
        }
        unsafe extern "system" fn InsertBody<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            location: BODYLOCATION,
            hpivot: *mut HBODY__,
            phbody: *mut *mut HBODY__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::InsertBody(
                    this,
                    core::mem::transmute_copy(&location),
                    core::mem::transmute_copy(&hpivot),
                    core::mem::transmute_copy(&phbody),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetBody<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            location: BODYLOCATION,
            hpivot: *mut HBODY__,
            phbody: *mut *mut HBODY__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::GetBody(
                    this,
                    core::mem::transmute_copy(&location),
                    core::mem::transmute_copy(&hpivot),
                    core::mem::transmute_copy(&phbody),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteBody<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hbody: *mut HBODY__,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::DeleteBody(
                    this,
                    core::mem::transmute_copy(&hbody),
                    core::mem::transmute_copy(&dwflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn MoveBody<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            hbody: *mut HBODY__,
            location: BODYLOCATION,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::MoveBody(
                    this,
                    core::mem::transmute_copy(&hbody),
                    core::mem::transmute_copy(&location),
                )
                .into()
            }
        }
        unsafe extern "system" fn CountBodies<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hparent: *mut HBODY__,
            frecurse: u8,
            pcbodies: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::CountBodies(
                    this,
                    core::mem::transmute_copy(&hparent),
                    core::mem::transmute_copy(&frecurse),
                    core::mem::transmute_copy(&pcbodies),
                )
                .into()
            }
        }
        unsafe extern "system" fn FindFirst<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pfindbody: *mut FINDBODY,
            phbody: *mut *mut HBODY__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::FindFirst(
                    this,
                    core::mem::transmute_copy(&pfindbody),
                    core::mem::transmute_copy(&phbody),
                )
                .into()
            }
        }
        unsafe extern "system" fn FindNext<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pfindbody: *mut FINDBODY,
            phbody: *mut *mut HBODY__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::FindNext(
                    this,
                    core::mem::transmute_copy(&pfindbody),
                    core::mem::transmute_copy(&phbody),
                )
                .into()
            }
        }
        unsafe extern "system" fn ResolveURL<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hrelated: *mut HBODY__,
            pszbase: windows_core::PCSTR,
            pszurl: windows_core::PCSTR,
            dwflags: u32,
            phbody: *mut *mut HBODY__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::ResolveURL(
                    this,
                    core::mem::transmute_copy(&hrelated),
                    core::mem::transmute(&pszbase),
                    core::mem::transmute(&pszurl),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute_copy(&phbody),
                )
                .into()
            }
        }
        unsafe extern "system" fn ToMultipart<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hbody: *mut HBODY__,
            pszsubtype: windows_core::PCSTR,
            phmultipart: *mut *mut HBODY__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::ToMultipart(
                    this,
                    core::mem::transmute_copy(&hbody),
                    core::mem::transmute(&pszsubtype),
                    core::mem::transmute_copy(&phmultipart),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetBodyOffsets<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hbody: *mut HBODY__,
            poffsets: *mut BODYOFFSETS,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::GetBodyOffsets(
                    this,
                    core::mem::transmute_copy(&hbody),
                    core::mem::transmute_copy(&poffsets),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetCharset<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            phcharset: *mut *mut HCHARSET__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::GetCharset(this, core::mem::transmute_copy(&phcharset))
                    .into()
            }
        }
        unsafe extern "system" fn SetCharset<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hcharset: *mut HCHARSET__,
            applytype: CSETAPPLYTYPE,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::SetCharset(
                    this,
                    core::mem::transmute_copy(&hcharset),
                    core::mem::transmute_copy(&applytype),
                )
                .into()
            }
        }
        unsafe extern "system" fn IsBodyType<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hbody: *mut HBODY__,
            bodytype: IMSGBODYTYPE,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::IsBodyType(
                    this,
                    core::mem::transmute_copy(&hbody),
                    core::mem::transmute_copy(&bodytype),
                )
                .into()
            }
        }
        unsafe extern "system" fn IsContentType<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hbody: *mut HBODY__,
            pszpritype: windows_core::PCSTR,
            pszsubtype: windows_core::PCSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::IsContentType(
                    this,
                    core::mem::transmute_copy(&hbody),
                    core::mem::transmute(&pszpritype),
                    core::mem::transmute(&pszsubtype),
                )
                .into()
            }
        }
        unsafe extern "system" fn QueryBodyProp<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hbody: *mut HBODY__,
            pszname: windows_core::PCSTR,
            pszcriteria: windows_core::PCSTR,
            fsubstring: u8,
            fcasesensitive: u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::QueryBodyProp(
                    this,
                    core::mem::transmute_copy(&hbody),
                    core::mem::transmute(&pszname),
                    core::mem::transmute(&pszcriteria),
                    core::mem::transmute_copy(&fsubstring),
                    core::mem::transmute_copy(&fcasesensitive),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetBodyProp<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hbody: *mut HBODY__,
            pszname: windows_core::PCSTR,
            dwflags: u32,
            pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::GetBodyProp(
                    this,
                    core::mem::transmute_copy(&hbody),
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute_copy(&pvalue),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetBodyProp<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hbody: *mut HBODY__,
            pszname: windows_core::PCSTR,
            dwflags: u32,
            pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::SetBodyProp(
                    this,
                    core::mem::transmute_copy(&hbody),
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute_copy(&pvalue),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteBodyProp<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hbody: *mut HBODY__,
            pszname: windows_core::PCSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::DeleteBodyProp(
                    this,
                    core::mem::transmute_copy(&hbody),
                    core::mem::transmute(&pszname),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetOption<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            oid: u32,
            pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::SetOption(
                    this,
                    core::mem::transmute_copy(&oid),
                    core::mem::transmute_copy(&pvalue),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetOption<
            Identity: IMimeMessageTree_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            oid: u32,
            pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeMessageTree_Impl::GetOption(
                    this,
                    core::mem::transmute_copy(&oid),
                    core::mem::transmute_copy(&pvalue),
                )
                .into()
            }
        }
        Self {
            base__: windows::Win32::System::Com::IPersistStreamInit_Vtbl::new::<Identity, OFFSET>(),
            Save: Save::<Identity, OFFSET>,
            GetSizeMax: GetSizeMax::<Identity, OFFSET>,
            InitNew: InitNew::<Identity, OFFSET>,
            GetMessageSource: GetMessageSource::<Identity, OFFSET>,
            GetMessageSize: GetMessageSize::<Identity, OFFSET>,
            LoadOffsetTable: LoadOffsetTable::<Identity, OFFSET>,
            SaveOffsetTable: SaveOffsetTable::<Identity, OFFSET>,
            GetFlags: GetFlags::<Identity, OFFSET>,
            Commit: Commit::<Identity, OFFSET>,
            HandsOffStorage: HandsOffStorage::<Identity, OFFSET>,
            BindToObject: BindToObject::<Identity, OFFSET>,
            SaveBody: SaveBody::<Identity, OFFSET>,
            InsertBody: InsertBody::<Identity, OFFSET>,
            GetBody: GetBody::<Identity, OFFSET>,
            DeleteBody: DeleteBody::<Identity, OFFSET>,
            MoveBody: MoveBody::<Identity, OFFSET>,
            CountBodies: CountBodies::<Identity, OFFSET>,
            FindFirst: FindFirst::<Identity, OFFSET>,
            FindNext: FindNext::<Identity, OFFSET>,
            ResolveURL: ResolveURL::<Identity, OFFSET>,
            ToMultipart: ToMultipart::<Identity, OFFSET>,
            GetBodyOffsets: GetBodyOffsets::<Identity, OFFSET>,
            GetCharset: GetCharset::<Identity, OFFSET>,
            SetCharset: SetCharset::<Identity, OFFSET>,
            IsBodyType: IsBodyType::<Identity, OFFSET>,
            IsContentType: IsContentType::<Identity, OFFSET>,
            QueryBodyProp: QueryBodyProp::<Identity, OFFSET>,
            GetBodyProp: GetBodyProp::<Identity, OFFSET>,
            SetBodyProp: SetBodyProp::<Identity, OFFSET>,
            DeleteBodyProp: DeleteBodyProp::<Identity, OFFSET>,
            SetOption: SetOption::<Identity, OFFSET>,
            GetOption: GetOption::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == & < IMimeMessageTree as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersist as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersistStreamInit as windows_core::Interface >::IID
    }
}
impl windows_core::RuntimeName for IMimeMessageTree {}
windows_core::imp::define_interface!(
    IMimeObjResolver,
    IMimeObjResolver_Vtbl,
    0xfeceaffd_c441_11d1_960e_00c04fbd7c09
);
windows_core::imp::interface_hierarchy!(IMimeObjResolver, windows_core::IUnknown);
impl IMimeObjResolver {
    pub unsafe fn MimeOleObjectFromMoniker<P1, P2>(
        &self,
        bindf: windows::Win32::System::Com::Urlmon::BINDF,
        pmkoriginal: P1,
        pbindctx: P2,
        riid: *const windows_core::GUID,
        ppvobject: *mut *mut core::ffi::c_void,
        ppmknew: *mut Option<windows::Win32::System::Com::IMoniker>,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<windows::Win32::System::Com::IMoniker>,
        P2: windows_core::Param<windows::Win32::System::Com::IBindCtx>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).MimeOleObjectFromMoniker)(
                windows_core::Interface::as_raw(self),
                bindf,
                pmkoriginal.param().abi(),
                pbindctx.param().abi(),
                riid,
                ppvobject as _,
                core::mem::transmute(ppmknew),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeObjResolver_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub MimeOleObjectFromMoniker: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows::Win32::System::Com::Urlmon::BINDF,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *const windows_core::GUID,
        *mut *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMimeObjResolver_Impl: windows_core::IUnknownImpl {
    fn MimeOleObjectFromMoniker(
        &self,
        bindf: windows::Win32::System::Com::Urlmon::BINDF,
        pmkoriginal: windows_core::Ref<'_, windows::Win32::System::Com::IMoniker>,
        pbindctx: windows_core::Ref<'_, windows::Win32::System::Com::IBindCtx>,
        riid: *const windows_core::GUID,
        ppvobject: *mut *mut core::ffi::c_void,
        ppmknew: windows_core::OutRef<'_, windows::Win32::System::Com::IMoniker>,
    ) -> windows_core::Result<()>;
}
impl IMimeObjResolver_Vtbl {
    pub const fn new<Identity: IMimeObjResolver_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn MimeOleObjectFromMoniker<
            Identity: IMimeObjResolver_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            bindf: windows::Win32::System::Com::Urlmon::BINDF,
            pmkoriginal: *mut core::ffi::c_void,
            pbindctx: *mut core::ffi::c_void,
            riid: *const windows_core::GUID,
            ppvobject: *mut *mut core::ffi::c_void,
            ppmknew: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeObjResolver_Impl::MimeOleObjectFromMoniker(
                    this,
                    core::mem::transmute_copy(&bindf),
                    core::mem::transmute_copy(&pmkoriginal),
                    core::mem::transmute_copy(&pbindctx),
                    core::mem::transmute_copy(&riid),
                    core::mem::transmute_copy(&ppvobject),
                    core::mem::transmute_copy(&ppmknew),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            MimeOleObjectFromMoniker: MimeOleObjectFromMoniker::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeObjResolver as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeObjResolver {}
windows_core::imp::define_interface!(
    IMimePropertySchema,
    IMimePropertySchema_Vtbl,
    0xfd853cec_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimePropertySchema, windows_core::IUnknown);
impl IMimePropertySchema {
    pub unsafe fn RegisterProperty<P0>(
        &self,
        pszname: P0,
        dwflags: u32,
        dwrownumber: u32,
        vtdefault: u16,
        pdwpropid: *mut u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).RegisterProperty)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                dwflags,
                dwrownumber,
                vtdefault,
                pdwpropid as _,
            )
            .ok()
        }
    }
    pub unsafe fn ModifyProperty<P0>(
        &self,
        pszname: P0,
        dwflags: u32,
        dwrownumber: u32,
        vtdefault: u16,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).ModifyProperty)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                dwflags,
                dwrownumber,
                vtdefault,
            )
            .ok()
        }
    }
    pub unsafe fn GetPropertyId<P0>(
        &self,
        pszname: P0,
        pdwpropid: *mut u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetPropertyId)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                pdwpropid as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetPropertyName(
        &self,
        dwpropid: u32,
        ppszname: *mut windows_core::PSTR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetPropertyName)(
                windows_core::Interface::as_raw(self),
                dwpropid,
                ppszname as _,
            )
            .ok()
        }
    }
    pub unsafe fn RegisterAddressType<P0>(
        &self,
        pszname: P0,
        pdwadrtype: *mut u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).RegisterAddressType)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                pdwadrtype as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimePropertySchema_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub RegisterProperty: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        u32,
        u32,
        u16,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub ModifyProperty: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        u32,
        u32,
        u16,
    ) -> windows_core::HRESULT,
    pub GetPropertyId: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub GetPropertyName: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut windows_core::PSTR,
    ) -> windows_core::HRESULT,
    pub RegisterAddressType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut u32,
    ) -> windows_core::HRESULT,
}
pub trait IMimePropertySchema_Impl: windows_core::IUnknownImpl {
    fn RegisterProperty(
        &self,
        pszname: &windows_core::PCSTR,
        dwflags: u32,
        dwrownumber: u32,
        vtdefault: u16,
        pdwpropid: *mut u32,
    ) -> windows_core::Result<()>;
    fn ModifyProperty(
        &self,
        pszname: &windows_core::PCSTR,
        dwflags: u32,
        dwrownumber: u32,
        vtdefault: u16,
    ) -> windows_core::Result<()>;
    fn GetPropertyId(
        &self,
        pszname: &windows_core::PCSTR,
        pdwpropid: *mut u32,
    ) -> windows_core::Result<()>;
    fn GetPropertyName(
        &self,
        dwpropid: u32,
        ppszname: *mut windows_core::PSTR,
    ) -> windows_core::Result<()>;
    fn RegisterAddressType(
        &self,
        pszname: &windows_core::PCSTR,
        pdwadrtype: *mut u32,
    ) -> windows_core::Result<()>;
}
impl IMimePropertySchema_Vtbl {
    pub const fn new<Identity: IMimePropertySchema_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn RegisterProperty<
            Identity: IMimePropertySchema_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            dwflags: u32,
            dwrownumber: u32,
            vtdefault: u16,
            pdwpropid: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySchema_Impl::RegisterProperty(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute_copy(&dwrownumber),
                    core::mem::transmute_copy(&vtdefault),
                    core::mem::transmute_copy(&pdwpropid),
                )
                .into()
            }
        }
        unsafe extern "system" fn ModifyProperty<
            Identity: IMimePropertySchema_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            dwflags: u32,
            dwrownumber: u32,
            vtdefault: u16,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySchema_Impl::ModifyProperty(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute_copy(&dwrownumber),
                    core::mem::transmute_copy(&vtdefault),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetPropertyId<
            Identity: IMimePropertySchema_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            pdwpropid: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySchema_Impl::GetPropertyId(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&pdwpropid),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetPropertyName<
            Identity: IMimePropertySchema_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwpropid: u32,
            ppszname: *mut windows_core::PSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySchema_Impl::GetPropertyName(
                    this,
                    core::mem::transmute_copy(&dwpropid),
                    core::mem::transmute_copy(&ppszname),
                )
                .into()
            }
        }
        unsafe extern "system" fn RegisterAddressType<
            Identity: IMimePropertySchema_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            pdwadrtype: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySchema_Impl::RegisterAddressType(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&pdwadrtype),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            RegisterProperty: RegisterProperty::<Identity, OFFSET>,
            ModifyProperty: ModifyProperty::<Identity, OFFSET>,
            GetPropertyId: GetPropertyId::<Identity, OFFSET>,
            GetPropertyName: GetPropertyName::<Identity, OFFSET>,
            RegisterAddressType: RegisterAddressType::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimePropertySchema as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimePropertySchema {}
windows_core::imp::define_interface!(
    IMimePropertySet,
    IMimePropertySet_Vtbl,
    0xfd853cd3_7f86_11d0_8252_00c04fd85ab4
);
impl core::ops::Deref for IMimePropertySet {
    type Target = windows::Win32::System::Com::IPersistStreamInit;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IMimePropertySet,
    windows_core::IUnknown,
    windows::Win32::System::Com::IPersist,
    windows::Win32::System::Com::IPersistStreamInit
);
impl IMimePropertySet {
    pub unsafe fn Save<P0>(&self, pstm: P0, fcleardirty: bool) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows::Win32::System::Com::IStream>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Save)(
                windows_core::Interface::as_raw(self),
                pstm.param().abi(),
                fcleardirty.into(),
            )
            .ok()
        }
    }
    pub unsafe fn GetSizeMax(&self) -> windows_core::Result<u64> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetSizeMax)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .map(|| result__)
        }
    }
    pub unsafe fn InitNew(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).InitNew)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn GetPropInfo<P0>(
        &self,
        pszname: P0,
        pinfo: *mut MIMEPROPINFO,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetPropInfo)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                pinfo as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetPropInfo<P0>(
        &self,
        pszname: P0,
        pinfo: *mut MIMEPROPINFO,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SetPropInfo)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                pinfo as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetPropA<P0>(
        &self,
        pszname: P0,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetPropA)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                dwflags,
                core::mem::transmute(pvalue),
            )
            .ok()
        }
    }
    pub unsafe fn SetPropA<P0>(
        &self,
        pszname: P0,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SetPropA)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                dwflags,
                core::mem::transmute(pvalue),
            )
            .ok()
        }
    }
    pub unsafe fn AppendProp<P0>(
        &self,
        pszname: P0,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).AppendProp)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                dwflags,
                core::mem::transmute(pvalue),
            )
            .ok()
        }
    }
    pub unsafe fn DeleteProp<P0>(&self, pszname: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteProp)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn CopyProps<P2>(
        &self,
        cnames: u32,
        prgszname: *const windows_core::PCSTR,
        ppropertyset: P2,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<IMimePropertySet>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).CopyProps)(
                windows_core::Interface::as_raw(self),
                cnames,
                prgszname,
                ppropertyset.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn MoveProps<P2>(
        &self,
        cnames: u32,
        prgszname: *const windows_core::PCSTR,
        ppropertyset: P2,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<IMimePropertySet>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).MoveProps)(
                windows_core::Interface::as_raw(self),
                cnames,
                prgszname,
                ppropertyset.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn DeleteExcept(
        &self,
        cnames: u32,
        prgszname: *const windows_core::PCSTR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteExcept)(
                windows_core::Interface::as_raw(self),
                cnames,
                prgszname,
            )
            .ok()
        }
    }
    pub unsafe fn QueryProp<P0, P1>(
        &self,
        pszname: P0,
        pszcriteria: P1,
        fsubstring: u8,
        fcasesensitive: u8,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).QueryProp)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                pszcriteria.param().abi(),
                fsubstring,
                fcasesensitive,
            )
            .ok()
        }
    }
    pub unsafe fn GetCharset(&self, phcharset: *mut *mut HCHARSET__) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetCharset)(
                windows_core::Interface::as_raw(self),
                phcharset as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetCharset(
        &self,
        hcharset: *mut HCHARSET__,
        applytype: CSETAPPLYTYPE,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetCharset)(
                windows_core::Interface::as_raw(self),
                hcharset as _,
                applytype,
            )
            .ok()
        }
    }
    pub unsafe fn GetParameters<P0>(
        &self,
        pszname: P0,
        pcparams: *mut u32,
        pprgparam: *mut *mut MIMEPARAMINFO,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetParameters)(
                windows_core::Interface::as_raw(self),
                pszname.param().abi(),
                pcparams as _,
                pprgparam as _,
            )
            .ok()
        }
    }
    pub unsafe fn IsContentType<P0, P1>(
        &self,
        pszpritype: P0,
        pszsubtype: P1,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCSTR>,
        P1: windows_core::Param<windows_core::PCSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).IsContentType)(
                windows_core::Interface::as_raw(self),
                pszpritype.param().abi(),
                pszsubtype.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn BindToObject(
        &self,
        riid: *const windows_core::GUID,
        ppvobject: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).BindToObject)(
                windows_core::Interface::as_raw(self),
                riid,
                ppvobject as _,
            )
            .ok()
        }
    }
    pub unsafe fn Clone(&self) -> windows_core::Result<IMimePropertySet> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).Clone)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn SetOption(
        &self,
        oid: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetOption)(
                windows_core::Interface::as_raw(self),
                oid,
                core::mem::transmute(pvalue),
            )
            .ok()
        }
    }
    pub unsafe fn GetOption(
        &self,
        oid: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetOption)(
                windows_core::Interface::as_raw(self),
                oid,
                core::mem::transmute(pvalue),
            )
            .ok()
        }
    }
    pub unsafe fn EnumPropsA(&self, dwflags: u32) -> windows_core::Result<IMimeEnumProperties> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).EnumPropsA)(
                windows_core::Interface::as_raw(self),
                dwflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
}
#[repr(C)]
pub struct IMimePropertySet_Vtbl {
    pub base__: windows::Win32::System::Com::IPersistStreamInit_Vtbl,
    pub Save: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        windows_core::BOOL,
    ) -> windows_core::HRESULT,
    pub GetSizeMax:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
    pub InitNew: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub GetPropInfo: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut MIMEPROPINFO,
    ) -> windows_core::HRESULT,
    pub SetPropInfo: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut MIMEPROPINFO,
    ) -> windows_core::HRESULT,
    pub GetPropA: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        u32,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
    pub SetPropA: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        u32,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
    pub AppendProp: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        u32,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
    pub DeleteProp: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
    ) -> windows_core::HRESULT,
    pub CopyProps: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *const windows_core::PCSTR,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub MoveProps: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *const windows_core::PCSTR,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub DeleteExcept: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *const windows_core::PCSTR,
    ) -> windows_core::HRESULT,
    pub QueryProp: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        windows_core::PCSTR,
        u8,
        u8,
    ) -> windows_core::HRESULT,
    pub GetCharset: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut HCHARSET__,
    ) -> windows_core::HRESULT,
    pub SetCharset: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut HCHARSET__,
        CSETAPPLYTYPE,
    ) -> windows_core::HRESULT,
    pub GetParameters: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        *mut u32,
        *mut *mut MIMEPARAMINFO,
    ) -> windows_core::HRESULT,
    pub IsContentType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCSTR,
        windows_core::PCSTR,
    ) -> windows_core::HRESULT,
    pub BindToObject: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *const windows_core::GUID,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Clone: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SetOption: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
    pub GetOption: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
    pub EnumPropsA: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMimePropertySet_Impl: windows::Win32::System::Com::IPersistStreamInit_Impl {
    fn Save(
        &self,
        pstm: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
        fcleardirty: windows_core::BOOL,
    ) -> windows_core::Result<()>;
    fn GetSizeMax(&self) -> windows_core::Result<u64>;
    fn InitNew(&self) -> windows_core::Result<()>;
    fn GetPropInfo(
        &self,
        pszname: &windows_core::PCSTR,
        pinfo: *mut MIMEPROPINFO,
    ) -> windows_core::Result<()>;
    fn SetPropInfo(
        &self,
        pszname: &windows_core::PCSTR,
        pinfo: *mut MIMEPROPINFO,
    ) -> windows_core::Result<()>;
    fn GetPropA(
        &self,
        pszname: &windows_core::PCSTR,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
    fn SetPropA(
        &self,
        pszname: &windows_core::PCSTR,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
    fn AppendProp(
        &self,
        pszname: &windows_core::PCSTR,
        dwflags: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
    fn DeleteProp(&self, pszname: &windows_core::PCSTR) -> windows_core::Result<()>;
    fn CopyProps(
        &self,
        cnames: u32,
        prgszname: *const windows_core::PCSTR,
        ppropertyset: windows_core::Ref<'_, IMimePropertySet>,
    ) -> windows_core::Result<()>;
    fn MoveProps(
        &self,
        cnames: u32,
        prgszname: *const windows_core::PCSTR,
        ppropertyset: windows_core::Ref<'_, IMimePropertySet>,
    ) -> windows_core::Result<()>;
    fn DeleteExcept(
        &self,
        cnames: u32,
        prgszname: *const windows_core::PCSTR,
    ) -> windows_core::Result<()>;
    fn QueryProp(
        &self,
        pszname: &windows_core::PCSTR,
        pszcriteria: &windows_core::PCSTR,
        fsubstring: u8,
        fcasesensitive: u8,
    ) -> windows_core::Result<()>;
    fn GetCharset(&self, phcharset: *mut *mut HCHARSET__) -> windows_core::Result<()>;
    fn SetCharset(
        &self,
        hcharset: *mut HCHARSET__,
        applytype: CSETAPPLYTYPE,
    ) -> windows_core::Result<()>;
    fn GetParameters(
        &self,
        pszname: &windows_core::PCSTR,
        pcparams: *mut u32,
        pprgparam: *mut *mut MIMEPARAMINFO,
    ) -> windows_core::Result<()>;
    fn IsContentType(
        &self,
        pszpritype: &windows_core::PCSTR,
        pszsubtype: &windows_core::PCSTR,
    ) -> windows_core::Result<()>;
    fn BindToObject(
        &self,
        riid: *const windows_core::GUID,
        ppvobject: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()>;
    fn Clone(&self) -> windows_core::Result<IMimePropertySet>;
    fn SetOption(
        &self,
        oid: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
    fn GetOption(
        &self,
        oid: u32,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
    fn EnumPropsA(&self, dwflags: u32) -> windows_core::Result<IMimeEnumProperties>;
}
impl IMimePropertySet_Vtbl {
    pub const fn new<Identity: IMimePropertySet_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Save<Identity: IMimePropertySet_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pstm: *mut core::ffi::c_void,
            fcleardirty: windows_core::BOOL,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::Save(
                    this,
                    core::mem::transmute_copy(&pstm),
                    core::mem::transmute_copy(&fcleardirty),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetSizeMax<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pcbsize: *mut u64,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimePropertySet_Impl::GetSizeMax(this) {
                    Ok(ok__) => {
                        pcbsize.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn InitNew<Identity: IMimePropertySet_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::InitNew(this).into()
            }
        }
        unsafe extern "system" fn GetPropInfo<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            pinfo: *mut MIMEPROPINFO,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::GetPropInfo(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&pinfo),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetPropInfo<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            pinfo: *mut MIMEPROPINFO,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::SetPropInfo(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&pinfo),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetPropA<Identity: IMimePropertySet_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            dwflags: u32,
            pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::GetPropA(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute_copy(&pvalue),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetPropA<Identity: IMimePropertySet_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            dwflags: u32,
            pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::SetPropA(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute_copy(&pvalue),
                )
                .into()
            }
        }
        unsafe extern "system" fn AppendProp<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            dwflags: u32,
            pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::AppendProp(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute_copy(&pvalue),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteProp<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::DeleteProp(this, core::mem::transmute(&pszname)).into()
            }
        }
        unsafe extern "system" fn CopyProps<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cnames: u32,
            prgszname: *const windows_core::PCSTR,
            ppropertyset: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::CopyProps(
                    this,
                    core::mem::transmute_copy(&cnames),
                    core::mem::transmute_copy(&prgszname),
                    core::mem::transmute_copy(&ppropertyset),
                )
                .into()
            }
        }
        unsafe extern "system" fn MoveProps<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cnames: u32,
            prgszname: *const windows_core::PCSTR,
            ppropertyset: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::MoveProps(
                    this,
                    core::mem::transmute_copy(&cnames),
                    core::mem::transmute_copy(&prgszname),
                    core::mem::transmute_copy(&ppropertyset),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteExcept<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cnames: u32,
            prgszname: *const windows_core::PCSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::DeleteExcept(
                    this,
                    core::mem::transmute_copy(&cnames),
                    core::mem::transmute_copy(&prgszname),
                )
                .into()
            }
        }
        unsafe extern "system" fn QueryProp<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            pszcriteria: windows_core::PCSTR,
            fsubstring: u8,
            fcasesensitive: u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::QueryProp(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute(&pszcriteria),
                    core::mem::transmute_copy(&fsubstring),
                    core::mem::transmute_copy(&fcasesensitive),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetCharset<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            phcharset: *mut *mut HCHARSET__,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::GetCharset(this, core::mem::transmute_copy(&phcharset))
                    .into()
            }
        }
        unsafe extern "system" fn SetCharset<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hcharset: *mut HCHARSET__,
            applytype: CSETAPPLYTYPE,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::SetCharset(
                    this,
                    core::mem::transmute_copy(&hcharset),
                    core::mem::transmute_copy(&applytype),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetParameters<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszname: windows_core::PCSTR,
            pcparams: *mut u32,
            pprgparam: *mut *mut MIMEPARAMINFO,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::GetParameters(
                    this,
                    core::mem::transmute(&pszname),
                    core::mem::transmute_copy(&pcparams),
                    core::mem::transmute_copy(&pprgparam),
                )
                .into()
            }
        }
        unsafe extern "system" fn IsContentType<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pszpritype: windows_core::PCSTR,
            pszsubtype: windows_core::PCSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::IsContentType(
                    this,
                    core::mem::transmute(&pszpritype),
                    core::mem::transmute(&pszsubtype),
                )
                .into()
            }
        }
        unsafe extern "system" fn BindToObject<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            riid: *const windows_core::GUID,
            ppvobject: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::BindToObject(
                    this,
                    core::mem::transmute_copy(&riid),
                    core::mem::transmute_copy(&ppvobject),
                )
                .into()
            }
        }
        unsafe extern "system" fn Clone<Identity: IMimePropertySet_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pppropertyset: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimePropertySet_Impl::Clone(this) {
                    Ok(ok__) => {
                        pppropertyset.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn SetOption<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            oid: u32,
            pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::SetOption(
                    this,
                    core::mem::transmute_copy(&oid),
                    core::mem::transmute_copy(&pvalue),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetOption<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            oid: u32,
            pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimePropertySet_Impl::GetOption(
                    this,
                    core::mem::transmute_copy(&oid),
                    core::mem::transmute_copy(&pvalue),
                )
                .into()
            }
        }
        unsafe extern "system" fn EnumPropsA<
            Identity: IMimePropertySet_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwflags: u32,
            ppenum: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMimePropertySet_Impl::EnumPropsA(this, core::mem::transmute_copy(&dwflags)) {
                    Ok(ok__) => {
                        ppenum.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows::Win32::System::Com::IPersistStreamInit_Vtbl::new::<Identity, OFFSET>(),
            Save: Save::<Identity, OFFSET>,
            GetSizeMax: GetSizeMax::<Identity, OFFSET>,
            InitNew: InitNew::<Identity, OFFSET>,
            GetPropInfo: GetPropInfo::<Identity, OFFSET>,
            SetPropInfo: SetPropInfo::<Identity, OFFSET>,
            GetPropA: GetPropA::<Identity, OFFSET>,
            SetPropA: SetPropA::<Identity, OFFSET>,
            AppendProp: AppendProp::<Identity, OFFSET>,
            DeleteProp: DeleteProp::<Identity, OFFSET>,
            CopyProps: CopyProps::<Identity, OFFSET>,
            MoveProps: MoveProps::<Identity, OFFSET>,
            DeleteExcept: DeleteExcept::<Identity, OFFSET>,
            QueryProp: QueryProp::<Identity, OFFSET>,
            GetCharset: GetCharset::<Identity, OFFSET>,
            SetCharset: SetCharset::<Identity, OFFSET>,
            GetParameters: GetParameters::<Identity, OFFSET>,
            IsContentType: IsContentType::<Identity, OFFSET>,
            BindToObject: BindToObject::<Identity, OFFSET>,
            Clone: Clone::<Identity, OFFSET>,
            SetOption: SetOption::<Identity, OFFSET>,
            GetOption: GetOption::<Identity, OFFSET>,
            EnumPropsA: EnumPropsA::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == & < IMimePropertySet as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersist as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersistStreamInit as windows_core::Interface >::IID
    }
}
impl windows_core::RuntimeName for IMimePropertySet {}
windows_core::imp::define_interface!(
    IMimeSecurity,
    IMimeSecurity_Vtbl,
    0xc5588353_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeSecurity, windows_core::IUnknown);
impl IMimeSecurity {
    pub unsafe fn InitNew(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).InitNew)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn CheckInit(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CheckInit)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn EncodeMessage<P0>(&self, ptree: P0, dwflags: u32) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMimeMessageTree>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).EncodeMessage)(
                windows_core::Interface::as_raw(self),
                ptree.param().abi(),
                dwflags,
            )
            .ok()
        }
    }
    pub unsafe fn EncodeBody<P0>(
        &self,
        ptree: P0,
        hencoderoot: *mut HBODY__,
        dwflags: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMimeMessageTree>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).EncodeBody)(
                windows_core::Interface::as_raw(self),
                ptree.param().abi(),
                hencoderoot as _,
                dwflags,
            )
            .ok()
        }
    }
    pub unsafe fn DecodeMessage<P0>(&self, ptree: P0, dwflags: u32) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMimeMessageTree>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DecodeMessage)(
                windows_core::Interface::as_raw(self),
                ptree.param().abi(),
                dwflags,
            )
            .ok()
        }
    }
    pub unsafe fn DecodeBody<P0>(
        &self,
        ptree: P0,
        hdecoderoot: *mut HBODY__,
        dwflags: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMimeMessageTree>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DecodeBody)(
                windows_core::Interface::as_raw(self),
                ptree.param().abi(),
                hdecoderoot as _,
                dwflags,
            )
            .ok()
        }
    }
    pub unsafe fn EnumCertificates(
        &self,
        hc: *mut core::ffi::c_void,
        dwusage: u32,
        pprev: *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
        ppcert: *mut *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).EnumCertificates)(
                windows_core::Interface::as_raw(self),
                hc as _,
                dwusage,
                pprev as _,
                ppcert as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetCertificateName(
        &self,
        px509cert: *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
        cn: CERTNAMETYPE,
        ppszname: *mut windows_core::PSTR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetCertificateName)(
                windows_core::Interface::as_raw(self),
                px509cert,
                cn,
                ppszname as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMessageType<P1>(
        &self,
        hwndparent: windows::Win32::Foundation::HWND,
        pbody: P1,
        pdwsectype: *mut u32,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<IMimeBody>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetMessageType)(
                windows_core::Interface::as_raw(self),
                hwndparent,
                pbody.param().abi(),
                pdwsectype as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetCertData(
        &self,
        px509cert: *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
        dataid: CERTDATAID,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetCertData)(
                windows_core::Interface::as_raw(self),
                px509cert,
                dataid,
                core::mem::transmute(pvalue),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeSecurity_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub InitNew: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub CheckInit: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub EncodeMessage: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub EncodeBody: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut HBODY__,
        u32,
    ) -> windows_core::HRESULT,
    pub DecodeMessage: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub DecodeBody: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut HBODY__,
        u32,
    ) -> windows_core::HRESULT,
    pub EnumCertificates: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
        *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
        *mut *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
    ) -> windows_core::HRESULT,
    pub GetCertificateName: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
        CERTNAMETYPE,
        *mut windows_core::PSTR,
    ) -> windows_core::HRESULT,
    pub GetMessageType: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows::Win32::Foundation::HWND,
        *mut core::ffi::c_void,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub GetCertData: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
        CERTDATAID,
        *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::HRESULT,
}
pub trait IMimeSecurity_Impl: windows_core::IUnknownImpl {
    fn InitNew(&self) -> windows_core::Result<()>;
    fn CheckInit(&self) -> windows_core::Result<()>;
    fn EncodeMessage(
        &self,
        ptree: windows_core::Ref<'_, IMimeMessageTree>,
        dwflags: u32,
    ) -> windows_core::Result<()>;
    fn EncodeBody(
        &self,
        ptree: windows_core::Ref<'_, IMimeMessageTree>,
        hencoderoot: *mut HBODY__,
        dwflags: u32,
    ) -> windows_core::Result<()>;
    fn DecodeMessage(
        &self,
        ptree: windows_core::Ref<'_, IMimeMessageTree>,
        dwflags: u32,
    ) -> windows_core::Result<()>;
    fn DecodeBody(
        &self,
        ptree: windows_core::Ref<'_, IMimeMessageTree>,
        hdecoderoot: *mut HBODY__,
        dwflags: u32,
    ) -> windows_core::Result<()>;
    fn EnumCertificates(
        &self,
        hc: *mut core::ffi::c_void,
        dwusage: u32,
        pprev: *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
        ppcert: *mut *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
    ) -> windows_core::Result<()>;
    fn GetCertificateName(
        &self,
        px509cert: *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
        cn: CERTNAMETYPE,
        ppszname: *mut windows_core::PSTR,
    ) -> windows_core::Result<()>;
    fn GetMessageType(
        &self,
        hwndparent: windows::Win32::Foundation::HWND,
        pbody: windows_core::Ref<'_, IMimeBody>,
        pdwsectype: *mut u32,
    ) -> windows_core::Result<()>;
    fn GetCertData(
        &self,
        px509cert: *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
        dataid: CERTDATAID,
        pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
    ) -> windows_core::Result<()>;
}
impl IMimeSecurity_Vtbl {
    pub const fn new<Identity: IMimeSecurity_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn InitNew<Identity: IMimeSecurity_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeSecurity_Impl::InitNew(this).into()
            }
        }
        unsafe extern "system" fn CheckInit<Identity: IMimeSecurity_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeSecurity_Impl::CheckInit(this).into()
            }
        }
        unsafe extern "system" fn EncodeMessage<
            Identity: IMimeSecurity_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ptree: *mut core::ffi::c_void,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeSecurity_Impl::EncodeMessage(
                    this,
                    core::mem::transmute_copy(&ptree),
                    core::mem::transmute_copy(&dwflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn EncodeBody<Identity: IMimeSecurity_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ptree: *mut core::ffi::c_void,
            hencoderoot: *mut HBODY__,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeSecurity_Impl::EncodeBody(
                    this,
                    core::mem::transmute_copy(&ptree),
                    core::mem::transmute_copy(&hencoderoot),
                    core::mem::transmute_copy(&dwflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn DecodeMessage<
            Identity: IMimeSecurity_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ptree: *mut core::ffi::c_void,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeSecurity_Impl::DecodeMessage(
                    this,
                    core::mem::transmute_copy(&ptree),
                    core::mem::transmute_copy(&dwflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn DecodeBody<Identity: IMimeSecurity_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ptree: *mut core::ffi::c_void,
            hdecoderoot: *mut HBODY__,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeSecurity_Impl::DecodeBody(
                    this,
                    core::mem::transmute_copy(&ptree),
                    core::mem::transmute_copy(&hdecoderoot),
                    core::mem::transmute_copy(&dwflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn EnumCertificates<
            Identity: IMimeSecurity_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hc: *mut core::ffi::c_void,
            dwusage: u32,
            pprev: *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
            ppcert: *mut *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeSecurity_Impl::EnumCertificates(
                    this,
                    core::mem::transmute_copy(&hc),
                    core::mem::transmute_copy(&dwusage),
                    core::mem::transmute_copy(&pprev),
                    core::mem::transmute_copy(&ppcert),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetCertificateName<
            Identity: IMimeSecurity_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            px509cert: *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
            cn: CERTNAMETYPE,
            ppszname: *mut windows_core::PSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeSecurity_Impl::GetCertificateName(
                    this,
                    core::mem::transmute_copy(&px509cert),
                    core::mem::transmute_copy(&cn),
                    core::mem::transmute_copy(&ppszname),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMessageType<
            Identity: IMimeSecurity_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hwndparent: windows::Win32::Foundation::HWND,
            pbody: *mut core::ffi::c_void,
            pdwsectype: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeSecurity_Impl::GetMessageType(
                    this,
                    core::mem::transmute_copy(&hwndparent),
                    core::mem::transmute_copy(&pbody),
                    core::mem::transmute_copy(&pdwsectype),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetCertData<Identity: IMimeSecurity_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            px509cert: *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
            dataid: CERTDATAID,
            pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeSecurity_Impl::GetCertData(
                    this,
                    core::mem::transmute_copy(&px509cert),
                    core::mem::transmute_copy(&dataid),
                    core::mem::transmute_copy(&pvalue),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            InitNew: InitNew::<Identity, OFFSET>,
            CheckInit: CheckInit::<Identity, OFFSET>,
            EncodeMessage: EncodeMessage::<Identity, OFFSET>,
            EncodeBody: EncodeBody::<Identity, OFFSET>,
            DecodeMessage: DecodeMessage::<Identity, OFFSET>,
            DecodeBody: DecodeBody::<Identity, OFFSET>,
            EnumCertificates: EnumCertificates::<Identity, OFFSET>,
            GetCertificateName: GetCertificateName::<Identity, OFFSET>,
            GetMessageType: GetMessageType::<Identity, OFFSET>,
            GetCertData: GetCertData::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeSecurity as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeSecurity {}
windows_core::imp::define_interface!(
    IMimeWebDocument,
    IMimeWebDocument_Vtbl,
    0xee519f11_851a_11d0_825c_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeWebDocument, windows_core::IUnknown);
impl IMimeWebDocument {
    pub unsafe fn GetURL(&self, ppszurl: *mut windows_core::PSTR) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetURL)(
                windows_core::Interface::as_raw(self),
                ppszurl as _,
            )
            .ok()
        }
    }
    pub unsafe fn BindToStorage(
        &self,
        riid: *const windows_core::GUID,
        ppvobject: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).BindToStorage)(
                windows_core::Interface::as_raw(self),
                riid,
                ppvobject as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMimeWebDocument_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetURL: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::PSTR,
    ) -> windows_core::HRESULT,
    pub BindToStorage: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *const windows_core::GUID,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMimeWebDocument_Impl: windows_core::IUnknownImpl {
    fn GetURL(&self, ppszurl: *mut windows_core::PSTR) -> windows_core::Result<()>;
    fn BindToStorage(
        &self,
        riid: *const windows_core::GUID,
        ppvobject: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()>;
}
impl IMimeWebDocument_Vtbl {
    pub const fn new<Identity: IMimeWebDocument_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetURL<Identity: IMimeWebDocument_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ppszurl: *mut windows_core::PSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeWebDocument_Impl::GetURL(this, core::mem::transmute_copy(&ppszurl)).into()
            }
        }
        unsafe extern "system" fn BindToStorage<
            Identity: IMimeWebDocument_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            riid: *const windows_core::GUID,
            ppvobject: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMimeWebDocument_Impl::BindToStorage(
                    this,
                    core::mem::transmute_copy(&riid),
                    core::mem::transmute_copy(&ppvobject),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetURL: GetURL::<Identity, OFFSET>,
            BindToStorage: BindToStorage::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMimeWebDocument as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMimeWebDocument {}
windows_core::imp::define_interface!(
    IMsgServiceAdmin,
    IMsgServiceAdmin_Vtbl,
    0x0002031d_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMsgServiceAdmin, windows_core::IUnknown);
impl IMsgServiceAdmin {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMsgServiceTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetMsgServiceTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn CreateMsgService(
        &self,
        lpszservice: *mut i8,
        lpszdisplayname: *mut i8,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CreateMsgService)(
                windows_core::Interface::as_raw(self),
                lpszservice as _,
                lpszdisplayname as _,
                uluiparam,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn DeleteMsgService(&self, lpuid: *mut MAPIUID) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteMsgService)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
            )
            .ok()
        }
    }
    pub unsafe fn CopyMsgService(
        &self,
        lpuid: *mut MAPIUID,
        lpszdisplayname: *mut i8,
        lpinterfacetocopy: *mut windows_core::GUID,
        lpinterfacedst: *mut windows_core::GUID,
        lpobjectdst: *mut core::ffi::c_void,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CopyMsgService)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                lpszdisplayname as _,
                lpinterfacetocopy as _,
                lpinterfacedst as _,
                lpobjectdst as _,
                uluiparam,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn RenameMsgService(
        &self,
        lpuid: *mut MAPIUID,
        ulflags: u32,
        lpszdisplayname: *mut i8,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).RenameMsgService)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                ulflags,
                lpszdisplayname as _,
            )
            .ok()
        }
    }
    pub unsafe fn ConfigureMsgService(
        &self,
        lpuid: *mut MAPIUID,
        uluiparam: usize,
        ulflags: u32,
        cvalues: u32,
        lpprops: *mut SPropValue,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ConfigureMsgService)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                uluiparam,
                ulflags,
                cvalues,
                lpprops as _,
            )
            .ok()
        }
    }
    pub unsafe fn OpenProfileSection(
        &self,
        lpuid: *mut MAPIUID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppprofsect: *mut Option<IProfSect>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenProfileSection)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                lpinterface as _,
                ulflags,
                core::mem::transmute(lppprofsect),
            )
            .ok()
        }
    }
    pub unsafe fn MsgServiceTransportOrder(
        &self,
        cuid: u32,
        lpuidlist: *mut MAPIUID,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).MsgServiceTransportOrder)(
                windows_core::Interface::as_raw(self),
                cuid,
                lpuidlist as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn AdminProviders(
        &self,
        lpuid: *mut MAPIUID,
        ulflags: u32,
        lppprovideradmin: *mut Option<IProviderAdmin>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).AdminProviders)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                ulflags,
                core::mem::transmute(lppprovideradmin),
            )
            .ok()
        }
    }
    pub unsafe fn SetPrimaryIdentity(
        &self,
        lpuid: *mut MAPIUID,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetPrimaryIdentity)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetProviderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetProviderTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
}
#[repr(C)]
pub struct IMsgServiceAdmin_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub GetMsgServiceTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CreateMsgService: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        *mut i8,
        usize,
        u32,
    ) -> windows_core::HRESULT,
    pub DeleteMsgService:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut MAPIUID) -> windows_core::HRESULT,
    pub CopyMsgService: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        *mut i8,
        *mut windows_core::GUID,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        usize,
        u32,
    ) -> windows_core::HRESULT,
    pub RenameMsgService: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        u32,
        *mut i8,
    ) -> windows_core::HRESULT,
    pub ConfigureMsgService: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        usize,
        u32,
        u32,
        *mut SPropValue,
    ) -> windows_core::HRESULT,
    pub OpenProfileSection: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        *mut windows_core::GUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub MsgServiceTransportOrder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut MAPIUID,
        u32,
    ) -> windows_core::HRESULT,
    pub AdminProviders: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SetPrimaryIdentity: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        u32,
    ) -> windows_core::HRESULT,
    pub GetProviderTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IMsgServiceAdmin_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn GetMsgServiceTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn CreateMsgService(
        &self,
        lpszservice: *mut i8,
        lpszdisplayname: *mut i8,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn DeleteMsgService(&self, lpuid: *mut MAPIUID) -> windows_core::Result<()>;
    fn CopyMsgService(
        &self,
        lpuid: *mut MAPIUID,
        lpszdisplayname: *mut i8,
        lpinterfacetocopy: *mut windows_core::GUID,
        lpinterfacedst: *mut windows_core::GUID,
        lpobjectdst: *mut core::ffi::c_void,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn RenameMsgService(
        &self,
        lpuid: *mut MAPIUID,
        ulflags: u32,
        lpszdisplayname: *mut i8,
    ) -> windows_core::Result<()>;
    fn ConfigureMsgService(
        &self,
        lpuid: *mut MAPIUID,
        uluiparam: usize,
        ulflags: u32,
        cvalues: u32,
        lpprops: *mut SPropValue,
    ) -> windows_core::Result<()>;
    fn OpenProfileSection(
        &self,
        lpuid: *mut MAPIUID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppprofsect: windows_core::OutRef<'_, IProfSect>,
    ) -> windows_core::Result<()>;
    fn MsgServiceTransportOrder(
        &self,
        cuid: u32,
        lpuidlist: *mut MAPIUID,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn AdminProviders(
        &self,
        lpuid: *mut MAPIUID,
        ulflags: u32,
        lppprovideradmin: windows_core::OutRef<'_, IProviderAdmin>,
    ) -> windows_core::Result<()>;
    fn SetPrimaryIdentity(&self, lpuid: *mut MAPIUID, ulflags: u32) -> windows_core::Result<()>;
    fn GetProviderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
}
impl IMsgServiceAdmin_Vtbl {
    pub const fn new<Identity: IMsgServiceAdmin_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IMsgServiceAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMsgServiceTable<
            Identity: IMsgServiceAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMsgServiceAdmin_Impl::GetMsgServiceTable(
                    this,
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn CreateMsgService<
            Identity: IMsgServiceAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservice: *mut i8,
            lpszdisplayname: *mut i8,
            uluiparam: usize,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin_Impl::CreateMsgService(
                    this,
                    core::mem::transmute_copy(&lpszservice),
                    core::mem::transmute_copy(&lpszdisplayname),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteMsgService<
            Identity: IMsgServiceAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin_Impl::DeleteMsgService(this, core::mem::transmute_copy(&lpuid))
                    .into()
            }
        }
        unsafe extern "system" fn CopyMsgService<
            Identity: IMsgServiceAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            lpszdisplayname: *mut i8,
            lpinterfacetocopy: *mut windows_core::GUID,
            lpinterfacedst: *mut windows_core::GUID,
            lpobjectdst: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin_Impl::CopyMsgService(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&lpszdisplayname),
                    core::mem::transmute_copy(&lpinterfacetocopy),
                    core::mem::transmute_copy(&lpinterfacedst),
                    core::mem::transmute_copy(&lpobjectdst),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn RenameMsgService<
            Identity: IMsgServiceAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            ulflags: u32,
            lpszdisplayname: *mut i8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin_Impl::RenameMsgService(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpszdisplayname),
                )
                .into()
            }
        }
        unsafe extern "system" fn ConfigureMsgService<
            Identity: IMsgServiceAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            uluiparam: usize,
            ulflags: u32,
            cvalues: u32,
            lpprops: *mut SPropValue,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin_Impl::ConfigureMsgService(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&cvalues),
                    core::mem::transmute_copy(&lpprops),
                )
                .into()
            }
        }
        unsafe extern "system" fn OpenProfileSection<
            Identity: IMsgServiceAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lppprofsect: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin_Impl::OpenProfileSection(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppprofsect),
                )
                .into()
            }
        }
        unsafe extern "system" fn MsgServiceTransportOrder<
            Identity: IMsgServiceAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cuid: u32,
            lpuidlist: *mut MAPIUID,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin_Impl::MsgServiceTransportOrder(
                    this,
                    core::mem::transmute_copy(&cuid),
                    core::mem::transmute_copy(&lpuidlist),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn AdminProviders<
            Identity: IMsgServiceAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            ulflags: u32,
            lppprovideradmin: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin_Impl::AdminProviders(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppprovideradmin),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetPrimaryIdentity<
            Identity: IMsgServiceAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin_Impl::SetPrimaryIdentity(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetProviderTable<
            Identity: IMsgServiceAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMsgServiceAdmin_Impl::GetProviderTable(
                    this,
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            GetMsgServiceTable: GetMsgServiceTable::<Identity, OFFSET>,
            CreateMsgService: CreateMsgService::<Identity, OFFSET>,
            DeleteMsgService: DeleteMsgService::<Identity, OFFSET>,
            CopyMsgService: CopyMsgService::<Identity, OFFSET>,
            RenameMsgService: RenameMsgService::<Identity, OFFSET>,
            ConfigureMsgService: ConfigureMsgService::<Identity, OFFSET>,
            OpenProfileSection: OpenProfileSection::<Identity, OFFSET>,
            MsgServiceTransportOrder: MsgServiceTransportOrder::<Identity, OFFSET>,
            AdminProviders: AdminProviders::<Identity, OFFSET>,
            SetPrimaryIdentity: SetPrimaryIdentity::<Identity, OFFSET>,
            GetProviderTable: GetProviderTable::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMsgServiceAdmin as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMsgServiceAdmin {}
windows_core::imp::define_interface!(
    IMsgServiceAdmin2,
    IMsgServiceAdmin2_Vtbl,
    0x00020387_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMsgServiceAdmin2, windows_core::IUnknown);
impl IMsgServiceAdmin2 {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMsgServiceTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetMsgServiceTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn CreateMsgService(
        &self,
        lpszservice: *mut i8,
        lpszdisplayname: *mut i8,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CreateMsgService)(
                windows_core::Interface::as_raw(self),
                lpszservice as _,
                lpszdisplayname as _,
                uluiparam,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn DeleteMsgService(&self, lpuid: *mut MAPIUID) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteMsgService)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
            )
            .ok()
        }
    }
    pub unsafe fn CopyMsgService(
        &self,
        lpuid: *mut MAPIUID,
        lpszdisplayname: *mut i8,
        lpinterfacetocopy: *mut windows_core::GUID,
        lpinterfacedst: *mut windows_core::GUID,
        lpobjectdst: *mut core::ffi::c_void,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CopyMsgService)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                lpszdisplayname as _,
                lpinterfacetocopy as _,
                lpinterfacedst as _,
                lpobjectdst as _,
                uluiparam,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn RenameMsgService(
        &self,
        lpuid: *mut MAPIUID,
        ulflags: u32,
        lpszdisplayname: *mut i8,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).RenameMsgService)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                ulflags,
                lpszdisplayname as _,
            )
            .ok()
        }
    }
    pub unsafe fn ConfigureMsgService(
        &self,
        lpuid: *mut MAPIUID,
        uluiparam: usize,
        ulflags: u32,
        cvalues: u32,
        lpprops: *mut SPropValue,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ConfigureMsgService)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                uluiparam,
                ulflags,
                cvalues,
                lpprops as _,
            )
            .ok()
        }
    }
    pub unsafe fn OpenProfileSection(
        &self,
        lpuid: *mut MAPIUID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppprofsect: *mut Option<IProfSect>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenProfileSection)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                lpinterface as _,
                ulflags,
                core::mem::transmute(lppprofsect),
            )
            .ok()
        }
    }
    pub unsafe fn MsgServiceTransportOrder(
        &self,
        cuid: u32,
        lpuidlist: *mut MAPIUID,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).MsgServiceTransportOrder)(
                windows_core::Interface::as_raw(self),
                cuid,
                lpuidlist as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn AdminProviders(
        &self,
        lpuid: *mut MAPIUID,
        ulflags: u32,
        lppprovideradmin: *mut Option<IProviderAdmin>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).AdminProviders)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                ulflags,
                core::mem::transmute(lppprovideradmin),
            )
            .ok()
        }
    }
    pub unsafe fn SetPrimaryIdentity(
        &self,
        lpuid: *mut MAPIUID,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetPrimaryIdentity)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetProviderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetProviderTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn CreateMsgServiceEx(
        &self,
        lpszservice: *mut i8,
        lpszdisplayname: *mut i8,
        uluiparam: usize,
        ulflags: u32,
        lpuidservice: *mut MAPIUID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CreateMsgServiceEx)(
                windows_core::Interface::as_raw(self),
                lpszservice as _,
                lpszdisplayname as _,
                uluiparam,
                ulflags,
                lpuidservice as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMsgServiceAdmin2_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub GetMsgServiceTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CreateMsgService: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        *mut i8,
        usize,
        u32,
    ) -> windows_core::HRESULT,
    pub DeleteMsgService:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut MAPIUID) -> windows_core::HRESULT,
    pub CopyMsgService: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        *mut i8,
        *mut windows_core::GUID,
        *mut windows_core::GUID,
        *mut core::ffi::c_void,
        usize,
        u32,
    ) -> windows_core::HRESULT,
    pub RenameMsgService: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        u32,
        *mut i8,
    ) -> windows_core::HRESULT,
    pub ConfigureMsgService: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        usize,
        u32,
        u32,
        *mut SPropValue,
    ) -> windows_core::HRESULT,
    pub OpenProfileSection: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        *mut windows_core::GUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub MsgServiceTransportOrder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut MAPIUID,
        u32,
    ) -> windows_core::HRESULT,
    pub AdminProviders: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SetPrimaryIdentity: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        u32,
    ) -> windows_core::HRESULT,
    pub GetProviderTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CreateMsgServiceEx: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        *mut i8,
        usize,
        u32,
        *mut MAPIUID,
    ) -> windows_core::HRESULT,
}
pub trait IMsgServiceAdmin2_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn GetMsgServiceTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn CreateMsgService(
        &self,
        lpszservice: *mut i8,
        lpszdisplayname: *mut i8,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn DeleteMsgService(&self, lpuid: *mut MAPIUID) -> windows_core::Result<()>;
    fn CopyMsgService(
        &self,
        lpuid: *mut MAPIUID,
        lpszdisplayname: *mut i8,
        lpinterfacetocopy: *mut windows_core::GUID,
        lpinterfacedst: *mut windows_core::GUID,
        lpobjectdst: *mut core::ffi::c_void,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn RenameMsgService(
        &self,
        lpuid: *mut MAPIUID,
        ulflags: u32,
        lpszdisplayname: *mut i8,
    ) -> windows_core::Result<()>;
    fn ConfigureMsgService(
        &self,
        lpuid: *mut MAPIUID,
        uluiparam: usize,
        ulflags: u32,
        cvalues: u32,
        lpprops: *mut SPropValue,
    ) -> windows_core::Result<()>;
    fn OpenProfileSection(
        &self,
        lpuid: *mut MAPIUID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppprofsect: windows_core::OutRef<'_, IProfSect>,
    ) -> windows_core::Result<()>;
    fn MsgServiceTransportOrder(
        &self,
        cuid: u32,
        lpuidlist: *mut MAPIUID,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn AdminProviders(
        &self,
        lpuid: *mut MAPIUID,
        ulflags: u32,
        lppprovideradmin: windows_core::OutRef<'_, IProviderAdmin>,
    ) -> windows_core::Result<()>;
    fn SetPrimaryIdentity(&self, lpuid: *mut MAPIUID, ulflags: u32) -> windows_core::Result<()>;
    fn GetProviderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn CreateMsgServiceEx(
        &self,
        lpszservice: *mut i8,
        lpszdisplayname: *mut i8,
        uluiparam: usize,
        ulflags: u32,
        lpuidservice: *mut MAPIUID,
    ) -> windows_core::Result<()>;
}
impl IMsgServiceAdmin2_Vtbl {
    pub const fn new<Identity: IMsgServiceAdmin2_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IMsgServiceAdmin2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin2_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMsgServiceTable<
            Identity: IMsgServiceAdmin2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMsgServiceAdmin2_Impl::GetMsgServiceTable(
                    this,
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn CreateMsgService<
            Identity: IMsgServiceAdmin2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservice: *mut i8,
            lpszdisplayname: *mut i8,
            uluiparam: usize,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin2_Impl::CreateMsgService(
                    this,
                    core::mem::transmute_copy(&lpszservice),
                    core::mem::transmute_copy(&lpszdisplayname),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteMsgService<
            Identity: IMsgServiceAdmin2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin2_Impl::DeleteMsgService(this, core::mem::transmute_copy(&lpuid))
                    .into()
            }
        }
        unsafe extern "system" fn CopyMsgService<
            Identity: IMsgServiceAdmin2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            lpszdisplayname: *mut i8,
            lpinterfacetocopy: *mut windows_core::GUID,
            lpinterfacedst: *mut windows_core::GUID,
            lpobjectdst: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin2_Impl::CopyMsgService(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&lpszdisplayname),
                    core::mem::transmute_copy(&lpinterfacetocopy),
                    core::mem::transmute_copy(&lpinterfacedst),
                    core::mem::transmute_copy(&lpobjectdst),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn RenameMsgService<
            Identity: IMsgServiceAdmin2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            ulflags: u32,
            lpszdisplayname: *mut i8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin2_Impl::RenameMsgService(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpszdisplayname),
                )
                .into()
            }
        }
        unsafe extern "system" fn ConfigureMsgService<
            Identity: IMsgServiceAdmin2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            uluiparam: usize,
            ulflags: u32,
            cvalues: u32,
            lpprops: *mut SPropValue,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin2_Impl::ConfigureMsgService(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&cvalues),
                    core::mem::transmute_copy(&lpprops),
                )
                .into()
            }
        }
        unsafe extern "system" fn OpenProfileSection<
            Identity: IMsgServiceAdmin2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lppprofsect: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin2_Impl::OpenProfileSection(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppprofsect),
                )
                .into()
            }
        }
        unsafe extern "system" fn MsgServiceTransportOrder<
            Identity: IMsgServiceAdmin2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            cuid: u32,
            lpuidlist: *mut MAPIUID,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin2_Impl::MsgServiceTransportOrder(
                    this,
                    core::mem::transmute_copy(&cuid),
                    core::mem::transmute_copy(&lpuidlist),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn AdminProviders<
            Identity: IMsgServiceAdmin2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            ulflags: u32,
            lppprovideradmin: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin2_Impl::AdminProviders(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppprovideradmin),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetPrimaryIdentity<
            Identity: IMsgServiceAdmin2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin2_Impl::SetPrimaryIdentity(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetProviderTable<
            Identity: IMsgServiceAdmin2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMsgServiceAdmin2_Impl::GetProviderTable(
                    this,
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn CreateMsgServiceEx<
            Identity: IMsgServiceAdmin2_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszservice: *mut i8,
            lpszdisplayname: *mut i8,
            uluiparam: usize,
            ulflags: u32,
            lpuidservice: *mut MAPIUID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgServiceAdmin2_Impl::CreateMsgServiceEx(
                    this,
                    core::mem::transmute_copy(&lpszservice),
                    core::mem::transmute_copy(&lpszdisplayname),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpuidservice),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            GetMsgServiceTable: GetMsgServiceTable::<Identity, OFFSET>,
            CreateMsgService: CreateMsgService::<Identity, OFFSET>,
            DeleteMsgService: DeleteMsgService::<Identity, OFFSET>,
            CopyMsgService: CopyMsgService::<Identity, OFFSET>,
            RenameMsgService: RenameMsgService::<Identity, OFFSET>,
            ConfigureMsgService: ConfigureMsgService::<Identity, OFFSET>,
            OpenProfileSection: OpenProfileSection::<Identity, OFFSET>,
            MsgServiceTransportOrder: MsgServiceTransportOrder::<Identity, OFFSET>,
            AdminProviders: AdminProviders::<Identity, OFFSET>,
            SetPrimaryIdentity: SetPrimaryIdentity::<Identity, OFFSET>,
            GetProviderTable: GetProviderTable::<Identity, OFFSET>,
            CreateMsgServiceEx: CreateMsgServiceEx::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMsgServiceAdmin2 as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMsgServiceAdmin2 {}
windows_core::imp::define_interface!(
    IMsgStore,
    IMsgStore_Vtbl,
    0x00020306_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMsgStore {
    type Target = IMAPIProp;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(IMsgStore, windows_core::IUnknown, IMAPIProp);
impl IMsgStore {
    pub unsafe fn Advise<P3>(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        uleventmask: u32,
        lpadvisesink: P3,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>
    where
        P3: windows_core::Param<IMAPIAdviseSink>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Advise)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                uleventmask,
                lpadvisesink.param().abi(),
                lpulconnection as _,
            )
            .ok()
        }
    }
    pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Unadvise)(
                windows_core::Interface::as_raw(self),
                ulconnection,
            )
            .ok()
        }
    }
    pub unsafe fn CompareEntryIDs(
        &self,
        cbentryid1: u32,
        lpentryid1: *mut ENTRYID,
        cbentryid2: u32,
        lpentryid2: *mut ENTRYID,
        ulflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CompareEntryIDs)(
                windows_core::Interface::as_raw(self),
                cbentryid1,
                lpentryid1 as _,
                cbentryid2,
                lpentryid2 as _,
                ulflags,
                lpulresult as _,
            )
            .ok()
        }
    }
    pub unsafe fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppunk: *mut Option<windows_core::IUnknown>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenEntry)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                lpinterface as _,
                ulflags,
                lpulobjtype as _,
                core::mem::transmute(lppunk),
            )
            .ok()
        }
    }
    pub unsafe fn SetReceiveFolder(
        &self,
        lpszmessageclass: *mut i8,
        ulflags: u32,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetReceiveFolder)(
                windows_core::Interface::as_raw(self),
                lpszmessageclass as _,
                ulflags,
                cbentryid,
                lpentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetReceiveFolder(
        &self,
        lpszmessageclass: *mut i8,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
        lppszexplicitclass: *mut *mut i8,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetReceiveFolder)(
                windows_core::Interface::as_raw(self),
                lpszmessageclass as _,
                ulflags,
                lpcbentryid as _,
                lppentryid as _,
                lppszexplicitclass as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetReceiveFolderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetReceiveFolderTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn StoreLogoff(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).StoreLogoff)(
                windows_core::Interface::as_raw(self),
                lpulflags as _,
            )
            .ok()
        }
    }
    pub unsafe fn AbortSubmit(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).AbortSubmit)(
                windows_core::Interface::as_raw(self),
                cbentryid,
                lpentryid as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetOutgoingQueue(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetOutgoingQueue)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn SetLockState<P0>(
        &self,
        lpmessage: P0,
        ullockstate: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SetLockState)(
                windows_core::Interface::as_raw(self),
                lpmessage.param().abi(),
                ullockstate,
            )
            .ok()
        }
    }
    pub unsafe fn FinishedMsg(
        &self,
        ulflags: u32,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FinishedMsg)(
                windows_core::Interface::as_raw(self),
                ulflags,
                cbentryid,
                lpentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn NotifyNewMail(
        &self,
        lpnotification: *mut NOTIFICATION,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).NotifyNewMail)(
                windows_core::Interface::as_raw(self),
                lpnotification as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IMsgStore_Vtbl {
    pub base__: IMAPIProp_Vtbl,
    pub Advise: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut core::ffi::c_void,
        *mut usize,
    ) -> windows_core::HRESULT,
    pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
    pub CompareEntryIDs: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
        *mut ENTRYID,
        u32,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub OpenEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        *mut windows_core::GUID,
        u32,
        *mut u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SetReceiveFolder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        u32,
        u32,
        *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub GetReceiveFolder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        u32,
        *mut u32,
        *mut *mut ENTRYID,
        *mut *mut i8,
    ) -> windows_core::HRESULT,
    pub GetReceiveFolderTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub StoreLogoff:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub AbortSubmit: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ENTRYID,
        u32,
    ) -> windows_core::HRESULT,
    pub GetOutgoingQueue: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub SetLockState: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub FinishedMsg: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut ENTRYID,
    ) -> windows_core::HRESULT,
    pub NotifyNewMail: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut NOTIFICATION,
    ) -> windows_core::HRESULT,
}
pub trait IMsgStore_Impl: IMAPIProp_Impl {
    fn Advise(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        uleventmask: u32,
        lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
        lpulconnection: *mut usize,
    ) -> windows_core::Result<()>;
    fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
    fn CompareEntryIDs(
        &self,
        cbentryid1: u32,
        lpentryid1: *mut ENTRYID,
        cbentryid2: u32,
        lpentryid2: *mut ENTRYID,
        ulflags: u32,
        lpulresult: *mut u32,
    ) -> windows_core::Result<()>;
    fn OpenEntry(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
    ) -> windows_core::Result<()>;
    fn SetReceiveFolder(
        &self,
        lpszmessageclass: *mut i8,
        ulflags: u32,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn GetReceiveFolder(
        &self,
        lpszmessageclass: *mut i8,
        ulflags: u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut ENTRYID,
        lppszexplicitclass: *mut *mut i8,
    ) -> windows_core::Result<()>;
    fn GetReceiveFolderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn StoreLogoff(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
    fn AbortSubmit(
        &self,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn GetOutgoingQueue(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn SetLockState(
        &self,
        lpmessage: windows_core::Ref<'_, IMessage>,
        ullockstate: u32,
    ) -> windows_core::Result<()>;
    fn FinishedMsg(
        &self,
        ulflags: u32,
        cbentryid: u32,
        lpentryid: *mut ENTRYID,
    ) -> windows_core::Result<()>;
    fn NotifyNewMail(&self, lpnotification: *mut NOTIFICATION) -> windows_core::Result<()>;
}
impl IMsgStore_Vtbl {
    pub const fn new<Identity: IMsgStore_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Advise<Identity: IMsgStore_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            uleventmask: u32,
            lpadvisesink: *mut core::ffi::c_void,
            lpulconnection: *mut usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgStore_Impl::Advise(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&uleventmask),
                    core::mem::transmute_copy(&lpadvisesink),
                    core::mem::transmute_copy(&lpulconnection),
                )
                .into()
            }
        }
        unsafe extern "system" fn Unadvise<Identity: IMsgStore_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulconnection: usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgStore_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
            }
        }
        unsafe extern "system" fn CompareEntryIDs<Identity: IMsgStore_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid1: u32,
            lpentryid1: *mut ENTRYID,
            cbentryid2: u32,
            lpentryid2: *mut ENTRYID,
            ulflags: u32,
            lpulresult: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgStore_Impl::CompareEntryIDs(
                    this,
                    core::mem::transmute_copy(&cbentryid1),
                    core::mem::transmute_copy(&lpentryid1),
                    core::mem::transmute_copy(&cbentryid2),
                    core::mem::transmute_copy(&lpentryid2),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulresult),
                )
                .into()
            }
        }
        unsafe extern "system" fn OpenEntry<Identity: IMsgStore_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lpulobjtype: *mut u32,
            lppunk: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgStore_Impl::OpenEntry(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulobjtype),
                    core::mem::transmute_copy(&lppunk),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetReceiveFolder<
            Identity: IMsgStore_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszmessageclass: *mut i8,
            ulflags: u32,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgStore_Impl::SetReceiveFolder(
                    this,
                    core::mem::transmute_copy(&lpszmessageclass),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetReceiveFolder<
            Identity: IMsgStore_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszmessageclass: *mut i8,
            ulflags: u32,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut ENTRYID,
            lppszexplicitclass: *mut *mut i8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgStore_Impl::GetReceiveFolder(
                    this,
                    core::mem::transmute_copy(&lpszmessageclass),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                    core::mem::transmute_copy(&lppszexplicitclass),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetReceiveFolderTable<
            Identity: IMsgStore_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMsgStore_Impl::GetReceiveFolderTable(
                    this,
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn StoreLogoff<Identity: IMsgStore_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulflags: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgStore_Impl::StoreLogoff(this, core::mem::transmute_copy(&lpulflags)).into()
            }
        }
        unsafe extern "system" fn AbortSubmit<Identity: IMsgStore_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgStore_Impl::AbortSubmit(
                    this,
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetOutgoingQueue<
            Identity: IMsgStore_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IMsgStore_Impl::GetOutgoingQueue(this, core::mem::transmute_copy(&ulflags)) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn SetLockState<Identity: IMsgStore_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpmessage: *mut core::ffi::c_void,
            ullockstate: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgStore_Impl::SetLockState(
                    this,
                    core::mem::transmute_copy(&lpmessage),
                    core::mem::transmute_copy(&ullockstate),
                )
                .into()
            }
        }
        unsafe extern "system" fn FinishedMsg<Identity: IMsgStore_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            cbentryid: u32,
            lpentryid: *mut ENTRYID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgStore_Impl::FinishedMsg(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&cbentryid),
                    core::mem::transmute_copy(&lpentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn NotifyNewMail<Identity: IMsgStore_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpnotification: *mut NOTIFICATION,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IMsgStore_Impl::NotifyNewMail(this, core::mem::transmute_copy(&lpnotification))
                    .into()
            }
        }
        Self {
            base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
            Advise: Advise::<Identity, OFFSET>,
            Unadvise: Unadvise::<Identity, OFFSET>,
            CompareEntryIDs: CompareEntryIDs::<Identity, OFFSET>,
            OpenEntry: OpenEntry::<Identity, OFFSET>,
            SetReceiveFolder: SetReceiveFolder::<Identity, OFFSET>,
            GetReceiveFolder: GetReceiveFolder::<Identity, OFFSET>,
            GetReceiveFolderTable: GetReceiveFolderTable::<Identity, OFFSET>,
            StoreLogoff: StoreLogoff::<Identity, OFFSET>,
            AbortSubmit: AbortSubmit::<Identity, OFFSET>,
            GetOutgoingQueue: GetOutgoingQueue::<Identity, OFFSET>,
            SetLockState: SetLockState::<Identity, OFFSET>,
            FinishedMsg: FinishedMsg::<Identity, OFFSET>,
            NotifyNewMail: NotifyNewMail::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IMsgStore as windows_core::Interface>::IID
            || iid == &<IMAPIProp as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IMsgStore {}
pub const IMsgStore_AbortSubmit: METHODS = METHODS(69i32);
pub const IMsgStore_Advise: METHODS = METHODS(61i32);
pub const IMsgStore_CompareEntryIDs: METHODS = METHODS(63i32);
pub const IMsgStore_FinishedMsg: METHODS = METHODS(72i32);
pub const IMsgStore_GetOutgoingQueue: METHODS = METHODS(70i32);
pub const IMsgStore_GetReceiveFolder: METHODS = METHODS(66i32);
pub const IMsgStore_GetReceiveFolderTable: METHODS = METHODS(67i32);
pub const IMsgStore_NotifyNewMail: METHODS = METHODS(73i32);
pub const IMsgStore_OpenEntry: METHODS = METHODS(64i32);
pub const IMsgStore_SetLockState: METHODS = METHODS(71i32);
pub const IMsgStore_SetReceiveFolder: METHODS = METHODS(65i32);
pub const IMsgStore_StoreLogoff: METHODS = METHODS(68i32);
pub const IMsgStore_Unadvise: METHODS = METHODS(62i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct INETCSETINFO {
    pub szName: [i8; 128],
    pub hCharset: *mut HCHARSET__,
    pub cpiWindows: u32,
    pub cpiInternet: u32,
    pub dwReserved1: u32,
}
impl Default for INETCSETINFO {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct INETLANGMASK(pub i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct INTTRACEENTRY {
    pub lAction: i32,
    pub ftArrivalTime: windows::Win32::Foundation::FILETIME,
    pub ftDeferredTime: windows::Win32::Foundation::FILETIME,
    pub rgchADMDName: [i8; 20],
    pub rgchCountryName: [i8; 4],
    pub rgchPRMDId: [i8; 20],
    pub rgchAttADMDName: [i8; 20],
    pub rgchAttCountryName: [i8; 4],
    pub rgchAttPRMDId: [i8; 20],
    pub rgchMTAName: [i8; 36],
    pub rgchAttMTAName: [i8; 35],
    pub bAdditionalActions: u8,
}
impl Default for INTTRACEENTRY {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct INTTRACEINFO {
    pub cEntries: u32,
    pub rgIntTraceEntry: [INTTRACEENTRY; 1],
}
impl Default for INTTRACEINFO {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
windows_core::imp::define_interface!(
    IOlkAccount,
    IOlkAccount_Vtbl,
    0x9240a6d2_af41_11d2_8c3b_00104b2a6676
);
impl core::ops::Deref for IOlkAccount {
    type Target = IOlkErrorUnknown;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(IOlkAccount, windows_core::IUnknown, IOlkErrorUnknown);
impl IOlkAccount {
    pub unsafe fn PlaceHolder1(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder1)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder2(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder2)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder3(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder3)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder4(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder4)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder5(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder5)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder6(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder6)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn GetAccountInfo(
        &self,
        pclsidtype: *mut windows_core::GUID,
        pccategories: *mut u32,
        prgclsidcategory: *mut *mut windows_core::GUID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetAccountInfo)(
                windows_core::Interface::as_raw(self),
                pclsidtype as _,
                pccategories as _,
                prgclsidcategory as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetPropA(
        &self,
        dwprop: u32,
        pvar: *mut ACCT_VARIANT,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetPropA)(
                windows_core::Interface::as_raw(self),
                dwprop,
                pvar as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetPropA(
        &self,
        dwprop: u32,
        pvar: *mut ACCT_VARIANT,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetPropA)(
                windows_core::Interface::as_raw(self),
                dwprop,
                pvar as _,
            )
            .ok()
        }
    }
    pub unsafe fn PlaceHolder7(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder7)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder8(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder8)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder9(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder9)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn FreeMemory(&self, pv: *mut u8) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FreeMemory)(
                windows_core::Interface::as_raw(self),
                pv as _,
            )
            .ok()
        }
    }
    pub unsafe fn PlaceHolder10(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder10)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn SaveChanges(&self, dwflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SaveChanges)(
                windows_core::Interface::as_raw(self),
                dwflags,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IOlkAccount_Vtbl {
    pub base__: IOlkErrorUnknown_Vtbl,
    pub PlaceHolder1: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder2: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder3: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder4: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder5: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder6: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub GetAccountInfo: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        *mut u32,
        *mut *mut windows_core::GUID,
    ) -> windows_core::HRESULT,
    pub GetPropA: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ACCT_VARIANT,
    ) -> windows_core::HRESULT,
    pub SetPropA: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ACCT_VARIANT,
    ) -> windows_core::HRESULT,
    pub PlaceHolder7: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder8: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder9: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub FreeMemory:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u8) -> windows_core::HRESULT,
    pub PlaceHolder10: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub SaveChanges:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
}
pub trait IOlkAccount_Impl: IOlkErrorUnknown_Impl {
    fn PlaceHolder1(&self) -> windows_core::Result<()>;
    fn PlaceHolder2(&self) -> windows_core::Result<()>;
    fn PlaceHolder3(&self) -> windows_core::Result<()>;
    fn PlaceHolder4(&self) -> windows_core::Result<()>;
    fn PlaceHolder5(&self) -> windows_core::Result<()>;
    fn PlaceHolder6(&self) -> windows_core::Result<()>;
    fn GetAccountInfo(
        &self,
        pclsidtype: *mut windows_core::GUID,
        pccategories: *mut u32,
        prgclsidcategory: *mut *mut windows_core::GUID,
    ) -> windows_core::Result<()>;
    fn GetPropA(&self, dwprop: u32, pvar: *mut ACCT_VARIANT) -> windows_core::Result<()>;
    fn SetPropA(&self, dwprop: u32, pvar: *mut ACCT_VARIANT) -> windows_core::Result<()>;
    fn PlaceHolder7(&self) -> windows_core::Result<()>;
    fn PlaceHolder8(&self) -> windows_core::Result<()>;
    fn PlaceHolder9(&self) -> windows_core::Result<()>;
    fn FreeMemory(&self, pv: *mut u8) -> windows_core::Result<()>;
    fn PlaceHolder10(&self) -> windows_core::Result<()>;
    fn SaveChanges(&self, dwflags: u32) -> windows_core::Result<()>;
}
impl IOlkAccount_Vtbl {
    pub const fn new<Identity: IOlkAccount_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn PlaceHolder1<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::PlaceHolder1(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder2<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::PlaceHolder2(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder3<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::PlaceHolder3(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder4<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::PlaceHolder4(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder5<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::PlaceHolder5(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder6<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::PlaceHolder6(this).into()
            }
        }
        unsafe extern "system" fn GetAccountInfo<
            Identity: IOlkAccount_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pclsidtype: *mut windows_core::GUID,
            pccategories: *mut u32,
            prgclsidcategory: *mut *mut windows_core::GUID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::GetAccountInfo(
                    this,
                    core::mem::transmute_copy(&pclsidtype),
                    core::mem::transmute_copy(&pccategories),
                    core::mem::transmute_copy(&prgclsidcategory),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetPropA<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            dwprop: u32,
            pvar: *mut ACCT_VARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::GetPropA(
                    this,
                    core::mem::transmute_copy(&dwprop),
                    core::mem::transmute_copy(&pvar),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetPropA<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            dwprop: u32,
            pvar: *mut ACCT_VARIANT,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::SetPropA(
                    this,
                    core::mem::transmute_copy(&dwprop),
                    core::mem::transmute_copy(&pvar),
                )
                .into()
            }
        }
        unsafe extern "system" fn PlaceHolder7<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::PlaceHolder7(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder8<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::PlaceHolder8(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder9<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::PlaceHolder9(this).into()
            }
        }
        unsafe extern "system" fn FreeMemory<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pv: *mut u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::FreeMemory(this, core::mem::transmute_copy(&pv)).into()
            }
        }
        unsafe extern "system" fn PlaceHolder10<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::PlaceHolder10(this).into()
            }
        }
        unsafe extern "system" fn SaveChanges<Identity: IOlkAccount_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccount_Impl::SaveChanges(this, core::mem::transmute_copy(&dwflags)).into()
            }
        }
        Self {
            base__: IOlkErrorUnknown_Vtbl::new::<Identity, OFFSET>(),
            PlaceHolder1: PlaceHolder1::<Identity, OFFSET>,
            PlaceHolder2: PlaceHolder2::<Identity, OFFSET>,
            PlaceHolder3: PlaceHolder3::<Identity, OFFSET>,
            PlaceHolder4: PlaceHolder4::<Identity, OFFSET>,
            PlaceHolder5: PlaceHolder5::<Identity, OFFSET>,
            PlaceHolder6: PlaceHolder6::<Identity, OFFSET>,
            GetAccountInfo: GetAccountInfo::<Identity, OFFSET>,
            GetPropA: GetPropA::<Identity, OFFSET>,
            SetPropA: SetPropA::<Identity, OFFSET>,
            PlaceHolder7: PlaceHolder7::<Identity, OFFSET>,
            PlaceHolder8: PlaceHolder8::<Identity, OFFSET>,
            PlaceHolder9: PlaceHolder9::<Identity, OFFSET>,
            FreeMemory: FreeMemory::<Identity, OFFSET>,
            PlaceHolder10: PlaceHolder10::<Identity, OFFSET>,
            SaveChanges: SaveChanges::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IOlkAccount as windows_core::Interface>::IID
            || iid == &<IOlkErrorUnknown as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IOlkAccount {}
windows_core::imp::define_interface!(
    IOlkAccountHelper,
    IOlkAccountHelper_Vtbl,
    0x9240a6cb_af41_11d2_8c3b_00104b2a6676
);
windows_core::imp::interface_hierarchy!(IOlkAccountHelper, windows_core::IUnknown);
impl IOlkAccountHelper {
    pub unsafe fn PlaceHolder1(&self, param0: *mut core::ffi::c_void) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder1)(
                windows_core::Interface::as_raw(self),
                param0 as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetIdentity<P0>(
        &self,
        pwszidentity: P0,
        pcch: *mut u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<windows_core::PCWSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).GetIdentity)(
                windows_core::Interface::as_raw(self),
                pwszidentity.param().abi(),
                pcch as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetMapiSession(&self) -> windows_core::Result<windows_core::IUnknown> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetMapiSession)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn HandsOffSession(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HandsOffSession)(
                windows_core::Interface::as_raw(self),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IOlkAccountHelper_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub PlaceHolder1: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub GetIdentity: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::PCWSTR,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub GetMapiSession: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub HandsOffSession: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IOlkAccountHelper_Impl: windows_core::IUnknownImpl {
    fn PlaceHolder1(&self, param0: *mut core::ffi::c_void) -> windows_core::Result<()>;
    fn GetIdentity(
        &self,
        pwszidentity: &windows_core::PCWSTR,
        pcch: *mut u32,
    ) -> windows_core::Result<()>;
    fn GetMapiSession(&self) -> windows_core::Result<windows_core::IUnknown>;
    fn HandsOffSession(&self) -> windows_core::Result<()>;
}
impl IOlkAccountHelper_Vtbl {
    pub const fn new<Identity: IOlkAccountHelper_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn PlaceHolder1<
            Identity: IOlkAccountHelper_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            param0: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountHelper_Impl::PlaceHolder1(this, core::mem::transmute_copy(&param0))
                    .into()
            }
        }
        unsafe extern "system" fn GetIdentity<
            Identity: IOlkAccountHelper_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pwszidentity: windows_core::PCWSTR,
            pcch: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountHelper_Impl::GetIdentity(
                    this,
                    core::mem::transmute(&pwszidentity),
                    core::mem::transmute_copy(&pcch),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetMapiSession<
            Identity: IOlkAccountHelper_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ppmsess: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IOlkAccountHelper_Impl::GetMapiSession(this) {
                    Ok(ok__) => {
                        ppmsess.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn HandsOffSession<
            Identity: IOlkAccountHelper_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountHelper_Impl::HandsOffSession(this).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            PlaceHolder1: PlaceHolder1::<Identity, OFFSET>,
            GetIdentity: GetIdentity::<Identity, OFFSET>,
            GetMapiSession: GetMapiSession::<Identity, OFFSET>,
            HandsOffSession: HandsOffSession::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IOlkAccountHelper as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IOlkAccountHelper {}
windows_core::imp::define_interface!(
    IOlkAccountManager,
    IOlkAccountManager_Vtbl,
    0x9240a6cd_af41_11d2_8c3b_00104b2a6676
);
impl core::ops::Deref for IOlkAccountManager {
    type Target = IOlkErrorUnknown;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IOlkAccountManager,
    windows_core::IUnknown,
    IOlkErrorUnknown
);
impl IOlkAccountManager {
    pub unsafe fn Init<P0>(&self, paccthelper: P0, dwflags: u32) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IOlkAccountHelper>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Init)(
                windows_core::Interface::as_raw(self),
                paccthelper.param().abi(),
                dwflags,
            )
            .ok()
        }
    }
    pub unsafe fn DisplayAccountList<P2>(
        &self,
        hwnd: windows::Win32::Foundation::HWND,
        dwflags: u32,
        wsztitle: P2,
        ccategories: u32,
        rgclsidcategories: *const windows_core::GUID,
        pclsidtype: *const windows_core::GUID,
    ) -> windows_core::Result<()>
    where
        P2: windows_core::Param<windows_core::PCWSTR>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).DisplayAccountList)(
                windows_core::Interface::as_raw(self),
                hwnd,
                dwflags,
                wsztitle.param().abi(),
                ccategories,
                rgclsidcategories,
                pclsidtype,
            )
            .ok()
        }
    }
    pub unsafe fn PlaceHolder1(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder1)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder2(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder2)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder3(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder3)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder4(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder4)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder5(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder5)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn FindAccount(
        &self,
        dwprop: u32,
        pvar: *mut ACCT_VARIANT,
        ppaccount: *mut Option<IOlkAccount>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FindAccount)(
                windows_core::Interface::as_raw(self),
                dwprop,
                pvar as _,
                core::mem::transmute(ppaccount),
            )
            .ok()
        }
    }
    pub unsafe fn PlaceHolder6(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder6)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder7(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder7)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder8(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder8)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn DeleteAccount(&self, dwacctid: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteAccount)(
                windows_core::Interface::as_raw(self),
                dwacctid,
            )
            .ok()
        }
    }
    pub unsafe fn PlaceHolder9(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder9)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn SaveChanges(&self, dwacctid: u32, dwflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SaveChanges)(
                windows_core::Interface::as_raw(self),
                dwacctid,
                dwflags,
            )
            .ok()
        }
    }
    pub unsafe fn GetOrder(
        &self,
        pclsidcategory: *const windows_core::GUID,
        pcaccts: *mut u32,
        prgaccts: *mut *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetOrder)(
                windows_core::Interface::as_raw(self),
                pclsidcategory,
                pcaccts as _,
                prgaccts as _,
            )
            .ok()
        }
    }
    pub unsafe fn SetOrder(
        &self,
        pclsidcategory: *const windows_core::GUID,
        pcaccts: *mut u32,
        prgaccts: *mut *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetOrder)(
                windows_core::Interface::as_raw(self),
                pclsidcategory,
                pcaccts as _,
                prgaccts as _,
            )
            .ok()
        }
    }
    pub unsafe fn EnumerateAccounts(
        &self,
        pclsidcategory: *const windows_core::GUID,
        pclsidtype: *const windows_core::GUID,
        dwflags: u32,
    ) -> windows_core::Result<IOlkEnum> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).EnumerateAccounts)(
                windows_core::Interface::as_raw(self),
                pclsidcategory,
                pclsidtype,
                dwflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn PlaceHolder10(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder10)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder11(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder11)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn FreeMemory(&self, pv: *mut u8) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FreeMemory)(
                windows_core::Interface::as_raw(self),
                pv as _,
            )
            .ok()
        }
    }
    pub unsafe fn Advise<P0>(&self, pnotify: P0, pdwcookie: *mut u32) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IOlkAccountNotify>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Advise)(
                windows_core::Interface::as_raw(self),
                pnotify.param().abi(),
                pdwcookie as _,
            )
            .ok()
        }
    }
    pub unsafe fn Unadvise(&self, pdwcookie: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Unadvise)(
                windows_core::Interface::as_raw(self),
                pdwcookie as _,
            )
            .ok()
        }
    }
    pub unsafe fn PlaceHolder12(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder12)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder13(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder13)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
    pub unsafe fn PlaceHolder14(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).PlaceHolder14)(windows_core::Interface::as_raw(
                self,
            ))
            .ok()
        }
    }
}
#[repr(C)]
pub struct IOlkAccountManager_Vtbl {
    pub base__: IOlkErrorUnknown_Vtbl,
    pub Init: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub DisplayAccountList: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows::Win32::Foundation::HWND,
        u32,
        windows_core::PCWSTR,
        u32,
        *const windows_core::GUID,
        *const windows_core::GUID,
    ) -> windows_core::HRESULT,
    pub PlaceHolder1: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder2: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder3: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder4: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder5: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub FindAccount: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut ACCT_VARIANT,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub PlaceHolder6: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder7: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder8: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub DeleteAccount:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub PlaceHolder9: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub SaveChanges:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32) -> windows_core::HRESULT,
    pub GetOrder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *const windows_core::GUID,
        *mut u32,
        *mut *mut u32,
    ) -> windows_core::HRESULT,
    pub SetOrder: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *const windows_core::GUID,
        *mut u32,
        *mut *mut u32,
    ) -> windows_core::HRESULT,
    pub EnumerateAccounts: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *const windows_core::GUID,
        *const windows_core::GUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub PlaceHolder10: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder11: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub FreeMemory:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u8) -> windows_core::HRESULT,
    pub Advise: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub Unadvise:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub PlaceHolder12: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder13: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub PlaceHolder14: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IOlkAccountManager_Impl: IOlkErrorUnknown_Impl {
    fn Init(
        &self,
        paccthelper: windows_core::Ref<'_, IOlkAccountHelper>,
        dwflags: u32,
    ) -> windows_core::Result<()>;
    fn DisplayAccountList(
        &self,
        hwnd: windows::Win32::Foundation::HWND,
        dwflags: u32,
        wsztitle: &windows_core::PCWSTR,
        ccategories: u32,
        rgclsidcategories: *const windows_core::GUID,
        pclsidtype: *const windows_core::GUID,
    ) -> windows_core::Result<()>;
    fn PlaceHolder1(&self) -> windows_core::Result<()>;
    fn PlaceHolder2(&self) -> windows_core::Result<()>;
    fn PlaceHolder3(&self) -> windows_core::Result<()>;
    fn PlaceHolder4(&self) -> windows_core::Result<()>;
    fn PlaceHolder5(&self) -> windows_core::Result<()>;
    fn FindAccount(
        &self,
        dwprop: u32,
        pvar: *mut ACCT_VARIANT,
        ppaccount: windows_core::OutRef<'_, IOlkAccount>,
    ) -> windows_core::Result<()>;
    fn PlaceHolder6(&self) -> windows_core::Result<()>;
    fn PlaceHolder7(&self) -> windows_core::Result<()>;
    fn PlaceHolder8(&self) -> windows_core::Result<()>;
    fn DeleteAccount(&self, dwacctid: u32) -> windows_core::Result<()>;
    fn PlaceHolder9(&self) -> windows_core::Result<()>;
    fn SaveChanges(&self, dwacctid: u32, dwflags: u32) -> windows_core::Result<()>;
    fn GetOrder(
        &self,
        pclsidcategory: *const windows_core::GUID,
        pcaccts: *mut u32,
        prgaccts: *mut *mut u32,
    ) -> windows_core::Result<()>;
    fn SetOrder(
        &self,
        pclsidcategory: *const windows_core::GUID,
        pcaccts: *mut u32,
        prgaccts: *mut *mut u32,
    ) -> windows_core::Result<()>;
    fn EnumerateAccounts(
        &self,
        pclsidcategory: *const windows_core::GUID,
        pclsidtype: *const windows_core::GUID,
        dwflags: u32,
    ) -> windows_core::Result<IOlkEnum>;
    fn PlaceHolder10(&self) -> windows_core::Result<()>;
    fn PlaceHolder11(&self) -> windows_core::Result<()>;
    fn FreeMemory(&self, pv: *mut u8) -> windows_core::Result<()>;
    fn Advise(
        &self,
        pnotify: windows_core::Ref<'_, IOlkAccountNotify>,
        pdwcookie: *mut u32,
    ) -> windows_core::Result<()>;
    fn Unadvise(&self, pdwcookie: *mut u32) -> windows_core::Result<()>;
    fn PlaceHolder12(&self) -> windows_core::Result<()>;
    fn PlaceHolder13(&self) -> windows_core::Result<()>;
    fn PlaceHolder14(&self) -> windows_core::Result<()>;
}
impl IOlkAccountManager_Vtbl {
    pub const fn new<Identity: IOlkAccountManager_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Init<Identity: IOlkAccountManager_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            paccthelper: *mut core::ffi::c_void,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::Init(
                    this,
                    core::mem::transmute_copy(&paccthelper),
                    core::mem::transmute_copy(&dwflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn DisplayAccountList<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hwnd: windows::Win32::Foundation::HWND,
            dwflags: u32,
            wsztitle: windows_core::PCWSTR,
            ccategories: u32,
            rgclsidcategories: *const windows_core::GUID,
            pclsidtype: *const windows_core::GUID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::DisplayAccountList(
                    this,
                    core::mem::transmute_copy(&hwnd),
                    core::mem::transmute_copy(&dwflags),
                    core::mem::transmute(&wsztitle),
                    core::mem::transmute_copy(&ccategories),
                    core::mem::transmute_copy(&rgclsidcategories),
                    core::mem::transmute_copy(&pclsidtype),
                )
                .into()
            }
        }
        unsafe extern "system" fn PlaceHolder1<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder1(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder2<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder2(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder3<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder3(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder4<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder4(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder5<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder5(this).into()
            }
        }
        unsafe extern "system" fn FindAccount<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwprop: u32,
            pvar: *mut ACCT_VARIANT,
            ppaccount: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::FindAccount(
                    this,
                    core::mem::transmute_copy(&dwprop),
                    core::mem::transmute_copy(&pvar),
                    core::mem::transmute_copy(&ppaccount),
                )
                .into()
            }
        }
        unsafe extern "system" fn PlaceHolder6<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder6(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder7<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder7(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder8<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder8(this).into()
            }
        }
        unsafe extern "system" fn DeleteAccount<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwacctid: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::DeleteAccount(this, core::mem::transmute_copy(&dwacctid))
                    .into()
            }
        }
        unsafe extern "system" fn PlaceHolder9<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder9(this).into()
            }
        }
        unsafe extern "system" fn SaveChanges<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            dwacctid: u32,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::SaveChanges(
                    this,
                    core::mem::transmute_copy(&dwacctid),
                    core::mem::transmute_copy(&dwflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetOrder<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pclsidcategory: *const windows_core::GUID,
            pcaccts: *mut u32,
            prgaccts: *mut *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::GetOrder(
                    this,
                    core::mem::transmute_copy(&pclsidcategory),
                    core::mem::transmute_copy(&pcaccts),
                    core::mem::transmute_copy(&prgaccts),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetOrder<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pclsidcategory: *const windows_core::GUID,
            pcaccts: *mut u32,
            prgaccts: *mut *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::SetOrder(
                    this,
                    core::mem::transmute_copy(&pclsidcategory),
                    core::mem::transmute_copy(&pcaccts),
                    core::mem::transmute_copy(&prgaccts),
                )
                .into()
            }
        }
        unsafe extern "system" fn EnumerateAccounts<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pclsidcategory: *const windows_core::GUID,
            pclsidtype: *const windows_core::GUID,
            dwflags: u32,
            ppenum: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IOlkAccountManager_Impl::EnumerateAccounts(
                    this,
                    core::mem::transmute_copy(&pclsidcategory),
                    core::mem::transmute_copy(&pclsidtype),
                    core::mem::transmute_copy(&dwflags),
                ) {
                    Ok(ok__) => {
                        ppenum.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn PlaceHolder10<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder10(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder11<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder11(this).into()
            }
        }
        unsafe extern "system" fn FreeMemory<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pv: *mut u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::FreeMemory(this, core::mem::transmute_copy(&pv)).into()
            }
        }
        unsafe extern "system" fn Advise<Identity: IOlkAccountManager_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pnotify: *mut core::ffi::c_void,
            pdwcookie: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::Advise(
                    this,
                    core::mem::transmute_copy(&pnotify),
                    core::mem::transmute_copy(&pdwcookie),
                )
                .into()
            }
        }
        unsafe extern "system" fn Unadvise<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pdwcookie: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::Unadvise(this, core::mem::transmute_copy(&pdwcookie))
                    .into()
            }
        }
        unsafe extern "system" fn PlaceHolder12<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder12(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder13<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder13(this).into()
            }
        }
        unsafe extern "system" fn PlaceHolder14<
            Identity: IOlkAccountManager_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkAccountManager_Impl::PlaceHolder14(this).into()
            }
        }
        Self {
            base__: IOlkErrorUnknown_Vtbl::new::<Identity, OFFSET>(),
            Init: Init::<Identity, OFFSET>,
            DisplayAccountList: DisplayAccountList::<Identity, OFFSET>,
            PlaceHolder1: PlaceHolder1::<Identity, OFFSET>,
            PlaceHolder2: PlaceHolder2::<Identity, OFFSET>,
            PlaceHolder3: PlaceHolder3::<Identity, OFFSET>,
            PlaceHolder4: PlaceHolder4::<Identity, OFFSET>,
            PlaceHolder5: PlaceHolder5::<Identity, OFFSET>,
            FindAccount: FindAccount::<Identity, OFFSET>,
            PlaceHolder6: PlaceHolder6::<Identity, OFFSET>,
            PlaceHolder7: PlaceHolder7::<Identity, OFFSET>,
            PlaceHolder8: PlaceHolder8::<Identity, OFFSET>,
            DeleteAccount: DeleteAccount::<Identity, OFFSET>,
            PlaceHolder9: PlaceHolder9::<Identity, OFFSET>,
            SaveChanges: SaveChanges::<Identity, OFFSET>,
            GetOrder: GetOrder::<Identity, OFFSET>,
            SetOrder: SetOrder::<Identity, OFFSET>,
            EnumerateAccounts: EnumerateAccounts::<Identity, OFFSET>,
            PlaceHolder10: PlaceHolder10::<Identity, OFFSET>,
            PlaceHolder11: PlaceHolder11::<Identity, OFFSET>,
            FreeMemory: FreeMemory::<Identity, OFFSET>,
            Advise: Advise::<Identity, OFFSET>,
            Unadvise: Unadvise::<Identity, OFFSET>,
            PlaceHolder12: PlaceHolder12::<Identity, OFFSET>,
            PlaceHolder13: PlaceHolder13::<Identity, OFFSET>,
            PlaceHolder14: PlaceHolder14::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IOlkAccountManager as windows_core::Interface>::IID
            || iid == &<IOlkErrorUnknown as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IOlkAccountManager {}
windows_core::imp::define_interface!(
    IOlkAccountNotify,
    IOlkAccountNotify_Vtbl,
    0x9240a6c3_af41_11d2_8c3b_00104b2a6676
);
impl core::ops::Deref for IOlkAccountNotify {
    type Target = IOlkErrorUnknown;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IOlkAccountNotify,
    windows_core::IUnknown,
    IOlkErrorUnknown
);
#[repr(C)]
pub struct IOlkAccountNotify_Vtbl {
    pub base__: IOlkErrorUnknown_Vtbl,
}
pub trait IOlkAccountNotify_Impl: IOlkErrorUnknown_Impl {}
impl IOlkAccountNotify_Vtbl {
    pub const fn new<Identity: IOlkAccountNotify_Impl, const OFFSET: isize>() -> Self {
        Self {
            base__: IOlkErrorUnknown_Vtbl::new::<Identity, OFFSET>(),
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IOlkAccountNotify as windows_core::Interface>::IID
            || iid == &<IOlkErrorUnknown as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IOlkAccountNotify {}
windows_core::imp::define_interface!(
    IOlkEnum,
    IOlkEnum_Vtbl,
    0x9240a6c0_af41_11d2_8c3b_00104b2a6676
);
windows_core::imp::interface_hierarchy!(IOlkEnum, windows_core::IUnknown);
impl IOlkEnum {
    pub unsafe fn GetCount(&self, pulcount: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetCount)(
                windows_core::Interface::as_raw(self),
                pulcount as _,
            )
            .ok()
        }
    }
    pub unsafe fn Reset(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn GetNext(&self) -> windows_core::Result<windows_core::IUnknown> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetNext)(
                windows_core::Interface::as_raw(self),
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn Skip(&self, cskip: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Skip)(
                windows_core::Interface::as_raw(self),
                cskip,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IOlkEnum_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetCount:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub GetNext: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
}
pub trait IOlkEnum_Impl: windows_core::IUnknownImpl {
    fn GetCount(&self, pulcount: *mut u32) -> windows_core::Result<()>;
    fn Reset(&self) -> windows_core::Result<()>;
    fn GetNext(&self) -> windows_core::Result<windows_core::IUnknown>;
    fn Skip(&self, cskip: u32) -> windows_core::Result<()>;
}
impl IOlkEnum_Vtbl {
    pub const fn new<Identity: IOlkEnum_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetCount<Identity: IOlkEnum_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pulcount: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkEnum_Impl::GetCount(this, core::mem::transmute_copy(&pulcount)).into()
            }
        }
        unsafe extern "system" fn Reset<Identity: IOlkEnum_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkEnum_Impl::Reset(this).into()
            }
        }
        unsafe extern "system" fn GetNext<Identity: IOlkEnum_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ppunk: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IOlkEnum_Impl::GetNext(this) {
                    Ok(ok__) => {
                        ppunk.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn Skip<Identity: IOlkEnum_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            cskip: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkEnum_Impl::Skip(this, core::mem::transmute_copy(&cskip)).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetCount: GetCount::<Identity, OFFSET>,
            Reset: Reset::<Identity, OFFSET>,
            GetNext: GetNext::<Identity, OFFSET>,
            Skip: Skip::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IOlkEnum as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IOlkEnum {}
windows_core::imp::define_interface!(
    IOlkErrorUnknown,
    IOlkErrorUnknown_Vtbl,
    0x9240a6c0_af41_11d2_8c3b_00104b2a6676
);
windows_core::imp::interface_hierarchy!(IOlkErrorUnknown, windows_core::IUnknown);
impl IOlkErrorUnknown {
    pub unsafe fn GetLastError(
        &self,
        hr: windows_core::HRESULT,
        ppwszerror: *mut windows_core::PWSTR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hr,
                ppwszerror as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IOlkErrorUnknown_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        *mut windows_core::PWSTR,
    ) -> windows_core::HRESULT,
}
pub trait IOlkErrorUnknown_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hr: windows_core::HRESULT,
        ppwszerror: *mut windows_core::PWSTR,
    ) -> windows_core::Result<()>;
}
impl IOlkErrorUnknown_Vtbl {
    pub const fn new<Identity: IOlkErrorUnknown_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IOlkErrorUnknown_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hr: windows_core::HRESULT,
            ppwszerror: *mut windows_core::PWSTR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IOlkErrorUnknown_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hr),
                    core::mem::transmute_copy(&ppwszerror),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IOlkErrorUnknown as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IOlkErrorUnknown {}
pub const IPROP_CLEAN: u32 = 65536u32;
pub const IPROP_DIRTY: u32 = 131072u32;
pub const IPROP_READONLY: u32 = 1u32;
pub const IPROP_READWRITE: u32 = 2u32;
windows_core::imp::define_interface!(
    IPersistMessage,
    IPersistMessage_Vtbl,
    0x0002032a_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IPersistMessage, windows_core::IUnknown);
impl IPersistMessage {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetClassID(
        &self,
        lpclassid: *mut windows_core::GUID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetClassID)(
                windows_core::Interface::as_raw(self),
                lpclassid as _,
            )
            .ok()
        }
    }
    pub unsafe fn IsDirty(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).IsDirty)(windows_core::Interface::as_raw(self))
                .ok()
        }
    }
    pub unsafe fn InitNew<P0, P1>(&self, pmessagesite: P0, pmessage: P1) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMAPIMessageSite>,
        P1: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).InitNew)(
                windows_core::Interface::as_raw(self),
                pmessagesite.param().abi(),
                pmessage.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn Load<P0, P1>(
        &self,
        pmessagesite: P0,
        pmessage: P1,
        ulmessagestatus: u32,
        ulmessageflags: u32,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMAPIMessageSite>,
        P1: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Load)(
                windows_core::Interface::as_raw(self),
                pmessagesite.param().abi(),
                pmessage.param().abi(),
                ulmessagestatus,
                ulmessageflags,
            )
            .ok()
        }
    }
    pub unsafe fn Save<P0>(&self, pmessage: P0, fsameasload: u32) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Save)(
                windows_core::Interface::as_raw(self),
                pmessage.param().abi(),
                fsameasload,
            )
            .ok()
        }
    }
    pub unsafe fn SaveCompleted<P0>(&self, pmessage: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SaveCompleted)(
                windows_core::Interface::as_raw(self),
                pmessage.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn HandsOffMessage(&self) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HandsOffMessage)(
                windows_core::Interface::as_raw(self),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IPersistMessage_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub GetClassID: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
    ) -> windows_core::HRESULT,
    pub IsDirty: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
    pub InitNew: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Load: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
        u32,
    ) -> windows_core::HRESULT,
    pub Save: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
    pub SaveCompleted: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub HandsOffMessage: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IPersistMessage_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn GetClassID(&self, lpclassid: *mut windows_core::GUID) -> windows_core::Result<()>;
    fn IsDirty(&self) -> windows_core::Result<()>;
    fn InitNew(
        &self,
        pmessagesite: windows_core::Ref<'_, IMAPIMessageSite>,
        pmessage: windows_core::Ref<'_, IMessage>,
    ) -> windows_core::Result<()>;
    fn Load(
        &self,
        pmessagesite: windows_core::Ref<'_, IMAPIMessageSite>,
        pmessage: windows_core::Ref<'_, IMessage>,
        ulmessagestatus: u32,
        ulmessageflags: u32,
    ) -> windows_core::Result<()>;
    fn Save(
        &self,
        pmessage: windows_core::Ref<'_, IMessage>,
        fsameasload: u32,
    ) -> windows_core::Result<()>;
    fn SaveCompleted(&self, pmessage: windows_core::Ref<'_, IMessage>) -> windows_core::Result<()>;
    fn HandsOffMessage(&self) -> windows_core::Result<()>;
}
impl IPersistMessage_Vtbl {
    pub const fn new<Identity: IPersistMessage_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IPersistMessage_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPersistMessage_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetClassID<
            Identity: IPersistMessage_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpclassid: *mut windows_core::GUID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPersistMessage_Impl::GetClassID(this, core::mem::transmute_copy(&lpclassid)).into()
            }
        }
        unsafe extern "system" fn IsDirty<Identity: IPersistMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPersistMessage_Impl::IsDirty(this).into()
            }
        }
        unsafe extern "system" fn InitNew<Identity: IPersistMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pmessagesite: *mut core::ffi::c_void,
            pmessage: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPersistMessage_Impl::InitNew(
                    this,
                    core::mem::transmute_copy(&pmessagesite),
                    core::mem::transmute_copy(&pmessage),
                )
                .into()
            }
        }
        unsafe extern "system" fn Load<Identity: IPersistMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pmessagesite: *mut core::ffi::c_void,
            pmessage: *mut core::ffi::c_void,
            ulmessagestatus: u32,
            ulmessageflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPersistMessage_Impl::Load(
                    this,
                    core::mem::transmute_copy(&pmessagesite),
                    core::mem::transmute_copy(&pmessage),
                    core::mem::transmute_copy(&ulmessagestatus),
                    core::mem::transmute_copy(&ulmessageflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn Save<Identity: IPersistMessage_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pmessage: *mut core::ffi::c_void,
            fsameasload: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPersistMessage_Impl::Save(
                    this,
                    core::mem::transmute_copy(&pmessage),
                    core::mem::transmute_copy(&fsameasload),
                )
                .into()
            }
        }
        unsafe extern "system" fn SaveCompleted<
            Identity: IPersistMessage_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            pmessage: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPersistMessage_Impl::SaveCompleted(this, core::mem::transmute_copy(&pmessage))
                    .into()
            }
        }
        unsafe extern "system" fn HandsOffMessage<
            Identity: IPersistMessage_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPersistMessage_Impl::HandsOffMessage(this).into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            GetClassID: GetClassID::<Identity, OFFSET>,
            IsDirty: IsDirty::<Identity, OFFSET>,
            InitNew: InitNew::<Identity, OFFSET>,
            Load: Load::<Identity, OFFSET>,
            Save: Save::<Identity, OFFSET>,
            SaveCompleted: SaveCompleted::<Identity, OFFSET>,
            HandsOffMessage: HandsOffMessage::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IPersistMessage as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IPersistMessage {}
windows_core::imp::define_interface!(
    IPersistMime,
    IPersistMime_Vtbl,
    0xde4ad8da_555f_11d1_8dd0_00c04fb951f9
);
impl core::ops::Deref for IPersistMime {
    type Target = windows::Win32::System::Com::IPersist;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(
    IPersistMime,
    windows_core::IUnknown,
    windows::Win32::System::Com::IPersist
);
impl IPersistMime {
    pub unsafe fn Load<P0>(&self, pmsg: P0) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMimeMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Load)(
                windows_core::Interface::as_raw(self),
                pmsg.param().abi(),
            )
            .ok()
        }
    }
    pub unsafe fn Save<P0>(&self, pmsg: P0, dwflags: u32) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMimeMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).Save)(
                windows_core::Interface::as_raw(self),
                pmsg.param().abi(),
                dwflags,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IPersistMime_Vtbl {
    pub base__: windows::Win32::System::Com::IPersist_Vtbl,
    pub Load: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Save: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        u32,
    ) -> windows_core::HRESULT,
}
pub trait IPersistMime_Impl: windows::Win32::System::Com::IPersist_Impl {
    fn Load(&self, pmsg: windows_core::Ref<'_, IMimeMessage>) -> windows_core::Result<()>;
    fn Save(
        &self,
        pmsg: windows_core::Ref<'_, IMimeMessage>,
        dwflags: u32,
    ) -> windows_core::Result<()>;
}
impl IPersistMime_Vtbl {
    pub const fn new<Identity: IPersistMime_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Load<Identity: IPersistMime_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pmsg: *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPersistMime_Impl::Load(this, core::mem::transmute_copy(&pmsg)).into()
            }
        }
        unsafe extern "system" fn Save<Identity: IPersistMime_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            pmsg: *mut core::ffi::c_void,
            dwflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPersistMime_Impl::Save(
                    this,
                    core::mem::transmute_copy(&pmsg),
                    core::mem::transmute_copy(&dwflags),
                )
                .into()
            }
        }
        Self {
            base__: windows::Win32::System::Com::IPersist_Vtbl::new::<Identity, OFFSET>(),
            Load: Load::<Identity, OFFSET>,
            Save: Save::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IPersistMime as windows_core::Interface>::IID
            || iid == &<windows::Win32::System::Com::IPersist as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IPersistMime {}
windows_core::imp::define_interface!(
    IProfAdmin,
    IProfAdmin_Vtbl,
    0x0002031c_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IProfAdmin, windows_core::IUnknown);
impl IProfAdmin {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetProfileTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetProfileTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn CreateProfile(
        &self,
        lpszprofilename: *mut i8,
        lpszpassword: *mut i8,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CreateProfile)(
                windows_core::Interface::as_raw(self),
                lpszprofilename as _,
                lpszpassword as _,
                uluiparam,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn DeleteProfile(
        &self,
        lpszprofilename: *mut i8,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteProfile)(
                windows_core::Interface::as_raw(self),
                lpszprofilename as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn ChangeProfilePassword(
        &self,
        lpszprofilename: *mut i8,
        lpszoldpassword: *mut i8,
        lpsznewpassword: *mut i8,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ChangeProfilePassword)(
                windows_core::Interface::as_raw(self),
                lpszprofilename as _,
                lpszoldpassword as _,
                lpsznewpassword as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn CopyProfile(
        &self,
        lpszoldprofilename: *mut i8,
        lpszoldpassword: *mut i8,
        lpsznewprofilename: *mut i8,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CopyProfile)(
                windows_core::Interface::as_raw(self),
                lpszoldprofilename as _,
                lpszoldpassword as _,
                lpsznewprofilename as _,
                uluiparam,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn RenameProfile(
        &self,
        lpszoldprofilename: *mut i8,
        lpszoldpassword: *mut i8,
        lpsznewprofilename: *mut i8,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).RenameProfile)(
                windows_core::Interface::as_raw(self),
                lpszoldprofilename as _,
                lpszoldpassword as _,
                lpsznewprofilename as _,
                uluiparam,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn SetDefaultProfile(
        &self,
        lpszprofilename: *mut i8,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).SetDefaultProfile)(
                windows_core::Interface::as_raw(self),
                lpszprofilename as _,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn AdminServices(
        &self,
        lpszprofilename: *mut i8,
        lpszpassword: *mut i8,
        uluiparam: usize,
        ulflags: u32,
        lppserviceadmin: *mut Option<IMsgServiceAdmin>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).AdminServices)(
                windows_core::Interface::as_raw(self),
                lpszprofilename as _,
                lpszpassword as _,
                uluiparam,
                ulflags,
                core::mem::transmute(lppserviceadmin),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IProfAdmin_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub GetProfileTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CreateProfile: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        *mut i8,
        usize,
        u32,
    ) -> windows_core::HRESULT,
    pub DeleteProfile:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut i8, u32) -> windows_core::HRESULT,
    pub ChangeProfilePassword: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        *mut i8,
        *mut i8,
        u32,
    ) -> windows_core::HRESULT,
    pub CopyProfile: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        *mut i8,
        *mut i8,
        usize,
        u32,
    ) -> windows_core::HRESULT,
    pub RenameProfile: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        *mut i8,
        *mut i8,
        usize,
        u32,
    ) -> windows_core::HRESULT,
    pub SetDefaultProfile:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut i8, u32) -> windows_core::HRESULT,
    pub AdminServices: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        *mut i8,
        usize,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IProfAdmin_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn GetProfileTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn CreateProfile(
        &self,
        lpszprofilename: *mut i8,
        lpszpassword: *mut i8,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn DeleteProfile(&self, lpszprofilename: *mut i8, ulflags: u32) -> windows_core::Result<()>;
    fn ChangeProfilePassword(
        &self,
        lpszprofilename: *mut i8,
        lpszoldpassword: *mut i8,
        lpsznewpassword: *mut i8,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn CopyProfile(
        &self,
        lpszoldprofilename: *mut i8,
        lpszoldpassword: *mut i8,
        lpsznewprofilename: *mut i8,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn RenameProfile(
        &self,
        lpszoldprofilename: *mut i8,
        lpszoldpassword: *mut i8,
        lpsznewprofilename: *mut i8,
        uluiparam: usize,
        ulflags: u32,
    ) -> windows_core::Result<()>;
    fn SetDefaultProfile(&self, lpszprofilename: *mut i8, ulflags: u32)
        -> windows_core::Result<()>;
    fn AdminServices(
        &self,
        lpszprofilename: *mut i8,
        lpszpassword: *mut i8,
        uluiparam: usize,
        ulflags: u32,
        lppserviceadmin: windows_core::OutRef<'_, IMsgServiceAdmin>,
    ) -> windows_core::Result<()>;
}
impl IProfAdmin_Vtbl {
    pub const fn new<Identity: IProfAdmin_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<Identity: IProfAdmin_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IProfAdmin_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetProfileTable<
            Identity: IProfAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IProfAdmin_Impl::GetProfileTable(this, core::mem::transmute_copy(&ulflags)) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn CreateProfile<Identity: IProfAdmin_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpszprofilename: *mut i8,
            lpszpassword: *mut i8,
            uluiparam: usize,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IProfAdmin_Impl::CreateProfile(
                    this,
                    core::mem::transmute_copy(&lpszprofilename),
                    core::mem::transmute_copy(&lpszpassword),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteProfile<Identity: IProfAdmin_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpszprofilename: *mut i8,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IProfAdmin_Impl::DeleteProfile(
                    this,
                    core::mem::transmute_copy(&lpszprofilename),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn ChangeProfilePassword<
            Identity: IProfAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszprofilename: *mut i8,
            lpszoldpassword: *mut i8,
            lpsznewpassword: *mut i8,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IProfAdmin_Impl::ChangeProfilePassword(
                    this,
                    core::mem::transmute_copy(&lpszprofilename),
                    core::mem::transmute_copy(&lpszoldpassword),
                    core::mem::transmute_copy(&lpsznewpassword),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn CopyProfile<Identity: IProfAdmin_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpszoldprofilename: *mut i8,
            lpszoldpassword: *mut i8,
            lpsznewprofilename: *mut i8,
            uluiparam: usize,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IProfAdmin_Impl::CopyProfile(
                    this,
                    core::mem::transmute_copy(&lpszoldprofilename),
                    core::mem::transmute_copy(&lpszoldpassword),
                    core::mem::transmute_copy(&lpsznewprofilename),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn RenameProfile<Identity: IProfAdmin_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpszoldprofilename: *mut i8,
            lpszoldpassword: *mut i8,
            lpsznewprofilename: *mut i8,
            uluiparam: usize,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IProfAdmin_Impl::RenameProfile(
                    this,
                    core::mem::transmute_copy(&lpszoldprofilename),
                    core::mem::transmute_copy(&lpszoldpassword),
                    core::mem::transmute_copy(&lpsznewprofilename),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn SetDefaultProfile<
            Identity: IProfAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszprofilename: *mut i8,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IProfAdmin_Impl::SetDefaultProfile(
                    this,
                    core::mem::transmute_copy(&lpszprofilename),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn AdminServices<Identity: IProfAdmin_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpszprofilename: *mut i8,
            lpszpassword: *mut i8,
            uluiparam: usize,
            ulflags: u32,
            lppserviceadmin: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IProfAdmin_Impl::AdminServices(
                    this,
                    core::mem::transmute_copy(&lpszprofilename),
                    core::mem::transmute_copy(&lpszpassword),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppserviceadmin),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            GetProfileTable: GetProfileTable::<Identity, OFFSET>,
            CreateProfile: CreateProfile::<Identity, OFFSET>,
            DeleteProfile: DeleteProfile::<Identity, OFFSET>,
            ChangeProfilePassword: ChangeProfilePassword::<Identity, OFFSET>,
            CopyProfile: CopyProfile::<Identity, OFFSET>,
            RenameProfile: RenameProfile::<Identity, OFFSET>,
            SetDefaultProfile: SetDefaultProfile::<Identity, OFFSET>,
            AdminServices: AdminServices::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IProfAdmin as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IProfAdmin {}
windows_core::imp::define_interface!(
    IProfSect,
    IProfSect_Vtbl,
    0x00020304_0000_0000_c000_000000000046
);
impl core::ops::Deref for IProfSect {
    type Target = IMAPIProp;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(IProfSect, windows_core::IUnknown, IMAPIProp);
#[repr(C)]
pub struct IProfSect_Vtbl {
    pub base__: IMAPIProp_Vtbl,
}
pub trait IProfSect_Impl: IMAPIProp_Impl {}
impl IProfSect_Vtbl {
    pub const fn new<Identity: IProfSect_Impl, const OFFSET: isize>() -> Self {
        Self {
            base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IProfSect as windows_core::Interface>::IID
            || iid == &<IMAPIProp as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IProfSect {}
windows_core::imp::define_interface!(IPropData, IPropData_Vtbl, 0);
impl core::ops::Deref for IPropData {
    type Target = IMAPIProp;
    fn deref(&self) -> &Self::Target {
        unsafe { core::mem::transmute(self) }
    }
}
windows_core::imp::interface_hierarchy!(IPropData, windows_core::IUnknown, IMAPIProp);
impl IPropData {
    pub unsafe fn HrSetObjAccess(&self, ulaccess: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HrSetObjAccess)(
                windows_core::Interface::as_raw(self),
                ulaccess,
            )
            .ok()
        }
    }
    pub unsafe fn HrSetPropAccess(
        &self,
        lpproptagarray: *mut SPropTagArray,
        rgulaccess: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HrSetPropAccess)(
                windows_core::Interface::as_raw(self),
                lpproptagarray as _,
                rgulaccess as _,
            )
            .ok()
        }
    }
    pub unsafe fn HrGetPropAccess(
        &self,
        lppproptagarray: *mut *mut SPropTagArray,
        lprgulaccess: *mut *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HrGetPropAccess)(
                windows_core::Interface::as_raw(self),
                lppproptagarray as _,
                lprgulaccess as _,
            )
            .ok()
        }
    }
    pub unsafe fn HrAddObjProps(
        &self,
        lppproptagarray: *mut SPropTagArray,
        lprgulaccess: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HrAddObjProps)(
                windows_core::Interface::as_raw(self),
                lppproptagarray as _,
                lprgulaccess as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IPropData_Vtbl {
    pub base__: IMAPIProp_Vtbl,
    pub HrSetObjAccess:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub HrSetPropAccess: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SPropTagArray,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub HrGetPropAccess: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut *mut SPropTagArray,
        *mut *mut u32,
    ) -> windows_core::HRESULT,
    pub HrAddObjProps: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SPropTagArray,
        *mut *mut SPropProblemArray,
    ) -> windows_core::HRESULT,
}
pub trait IPropData_Impl: IMAPIProp_Impl {
    fn HrSetObjAccess(&self, ulaccess: u32) -> windows_core::Result<()>;
    fn HrSetPropAccess(
        &self,
        lpproptagarray: *mut SPropTagArray,
        rgulaccess: *mut u32,
    ) -> windows_core::Result<()>;
    fn HrGetPropAccess(
        &self,
        lppproptagarray: *mut *mut SPropTagArray,
        lprgulaccess: *mut *mut u32,
    ) -> windows_core::Result<()>;
    fn HrAddObjProps(
        &self,
        lppproptagarray: *mut SPropTagArray,
        lprgulaccess: *mut *mut SPropProblemArray,
    ) -> windows_core::Result<()>;
}
impl IPropData_Vtbl {
    pub const fn new<Identity: IPropData_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn HrSetObjAccess<Identity: IPropData_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulaccess: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPropData_Impl::HrSetObjAccess(this, core::mem::transmute_copy(&ulaccess)).into()
            }
        }
        unsafe extern "system" fn HrSetPropAccess<Identity: IPropData_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpproptagarray: *mut SPropTagArray,
            rgulaccess: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPropData_Impl::HrSetPropAccess(
                    this,
                    core::mem::transmute_copy(&lpproptagarray),
                    core::mem::transmute_copy(&rgulaccess),
                )
                .into()
            }
        }
        unsafe extern "system" fn HrGetPropAccess<Identity: IPropData_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lppproptagarray: *mut *mut SPropTagArray,
            lprgulaccess: *mut *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPropData_Impl::HrGetPropAccess(
                    this,
                    core::mem::transmute_copy(&lppproptagarray),
                    core::mem::transmute_copy(&lprgulaccess),
                )
                .into()
            }
        }
        unsafe extern "system" fn HrAddObjProps<Identity: IPropData_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lppproptagarray: *mut SPropTagArray,
            lprgulaccess: *mut *mut SPropProblemArray,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IPropData_Impl::HrAddObjProps(
                    this,
                    core::mem::transmute_copy(&lppproptagarray),
                    core::mem::transmute_copy(&lprgulaccess),
                )
                .into()
            }
        }
        Self {
            base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
            HrSetObjAccess: HrSetObjAccess::<Identity, OFFSET>,
            HrSetPropAccess: HrSetPropAccess::<Identity, OFFSET>,
            HrGetPropAccess: HrGetPropAccess::<Identity, OFFSET>,
            HrAddObjProps: HrAddObjProps::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IPropData as windows_core::Interface>::IID
            || iid == &<IMAPIProp as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IPropData {}
windows_core::imp::define_interface!(
    IProviderAdmin,
    IProviderAdmin_Vtbl,
    0x00020325_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IProviderAdmin, windows_core::IUnknown);
impl IProviderAdmin {
    pub unsafe fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).GetLastError)(
                windows_core::Interface::as_raw(self),
                hresult,
                ulflags,
                lppmapierror as _,
            )
            .ok()
        }
    }
    pub unsafe fn GetProviderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
        unsafe {
            let mut result__ = core::mem::zeroed();
            (windows_core::Interface::vtable(self).GetProviderTable)(
                windows_core::Interface::as_raw(self),
                ulflags,
                &mut result__,
            )
            .and_then(|| windows_core::Type::from_abi(result__))
        }
    }
    pub unsafe fn CreateProvider(
        &self,
        lpszprovider: *mut i8,
        cvalues: u32,
        lpprops: *mut SPropValue,
        uluiparam: usize,
        ulflags: u32,
        lpuid: *mut MAPIUID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).CreateProvider)(
                windows_core::Interface::as_raw(self),
                lpszprovider as _,
                cvalues,
                lpprops as _,
                uluiparam,
                ulflags,
                lpuid as _,
            )
            .ok()
        }
    }
    pub unsafe fn DeleteProvider(&self, lpuid: *mut MAPIUID) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).DeleteProvider)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
            )
            .ok()
        }
    }
    pub unsafe fn OpenProfileSection(
        &self,
        lpuid: *mut MAPIUID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppprofsect: *mut Option<IProfSect>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenProfileSection)(
                windows_core::Interface::as_raw(self),
                lpuid as _,
                lpinterface as _,
                ulflags,
                core::mem::transmute(lppprofsect),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IProviderAdmin_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub GetLastError: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        windows_core::HRESULT,
        u32,
        *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
    pub GetProviderTable: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub CreateProvider: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut i8,
        u32,
        *mut SPropValue,
        usize,
        u32,
        *mut MAPIUID,
    ) -> windows_core::HRESULT,
    pub DeleteProvider:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut MAPIUID) -> windows_core::HRESULT,
    pub OpenProfileSection: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut MAPIUID,
        *mut windows_core::GUID,
        u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IProviderAdmin_Impl: windows_core::IUnknownImpl {
    fn GetLastError(
        &self,
        hresult: windows_core::HRESULT,
        ulflags: u32,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::Result<()>;
    fn GetProviderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
    fn CreateProvider(
        &self,
        lpszprovider: *mut i8,
        cvalues: u32,
        lpprops: *mut SPropValue,
        uluiparam: usize,
        ulflags: u32,
        lpuid: *mut MAPIUID,
    ) -> windows_core::Result<()>;
    fn DeleteProvider(&self, lpuid: *mut MAPIUID) -> windows_core::Result<()>;
    fn OpenProfileSection(
        &self,
        lpuid: *mut MAPIUID,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lppprofsect: windows_core::OutRef<'_, IProfSect>,
    ) -> windows_core::Result<()>;
}
impl IProviderAdmin_Vtbl {
    pub const fn new<Identity: IProviderAdmin_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn GetLastError<
            Identity: IProviderAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            hresult: windows_core::HRESULT,
            ulflags: u32,
            lppmapierror: *mut *mut MAPIERROR,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IProviderAdmin_Impl::GetLastError(
                    this,
                    core::mem::transmute_copy(&hresult),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppmapierror),
                )
                .into()
            }
        }
        unsafe extern "system" fn GetProviderTable<
            Identity: IProviderAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpptable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                match IProviderAdmin_Impl::GetProviderTable(
                    this,
                    core::mem::transmute_copy(&ulflags),
                ) {
                    Ok(ok__) => {
                        lpptable.write(core::mem::transmute(ok__));
                        windows_core::HRESULT(0)
                    }
                    Err(err) => err.into(),
                }
            }
        }
        unsafe extern "system" fn CreateProvider<
            Identity: IProviderAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpszprovider: *mut i8,
            cvalues: u32,
            lpprops: *mut SPropValue,
            uluiparam: usize,
            ulflags: u32,
            lpuid: *mut MAPIUID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IProviderAdmin_Impl::CreateProvider(
                    this,
                    core::mem::transmute_copy(&lpszprovider),
                    core::mem::transmute_copy(&cvalues),
                    core::mem::transmute_copy(&lpprops),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpuid),
                )
                .into()
            }
        }
        unsafe extern "system" fn DeleteProvider<
            Identity: IProviderAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IProviderAdmin_Impl::DeleteProvider(this, core::mem::transmute_copy(&lpuid)).into()
            }
        }
        unsafe extern "system" fn OpenProfileSection<
            Identity: IProviderAdmin_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpuid: *mut MAPIUID,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lppprofsect: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IProviderAdmin_Impl::OpenProfileSection(
                    this,
                    core::mem::transmute_copy(&lpuid),
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lppprofsect),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            GetLastError: GetLastError::<Identity, OFFSET>,
            GetProviderTable: GetProviderTable::<Identity, OFFSET>,
            CreateProvider: CreateProvider::<Identity, OFFSET>,
            DeleteProvider: DeleteProvider::<Identity, OFFSET>,
            OpenProfileSection: OpenProfileSection::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IProviderAdmin as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IProviderAdmin {}
windows_core::imp::define_interface!(
    ISpoolerHook,
    ISpoolerHook_Vtbl,
    0x00020320_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(ISpoolerHook, windows_core::IUnknown);
impl ISpoolerHook {
    pub unsafe fn InboundMsgHook<P0, P1, P2>(
        &self,
        lpmessage: P0,
        lpfolder: P1,
        lpmdb: P2,
        lpulflags: *mut u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut u8,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMessage>,
        P1: windows_core::Param<IMAPIFolder>,
        P2: windows_core::Param<IMsgStore>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).InboundMsgHook)(
                windows_core::Interface::as_raw(self),
                lpmessage.param().abi(),
                lpfolder.param().abi(),
                lpmdb.param().abi(),
                lpulflags as _,
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
    pub unsafe fn OutboundMsgHook<P0, P1, P2>(
        &self,
        lpmessage: P0,
        lpfolder: P1,
        lpmdb: P2,
        lpulflags: *mut u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut u8,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMessage>,
        P1: windows_core::Param<IMAPIFolder>,
        P2: windows_core::Param<IMsgStore>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).OutboundMsgHook)(
                windows_core::Interface::as_raw(self),
                lpmessage.param().abi(),
                lpfolder.param().abi(),
                lpmdb.param().abi(),
                lpulflags as _,
                lpcbentryid as _,
                lppentryid as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct ISpoolerHook_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub InboundMsgHook: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut u32,
        *mut u32,
        *mut *mut u8,
    ) -> windows_core::HRESULT,
    pub OutboundMsgHook: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        *mut u32,
        *mut u32,
        *mut *mut u8,
    ) -> windows_core::HRESULT,
}
pub trait ISpoolerHook_Impl: windows_core::IUnknownImpl {
    fn InboundMsgHook(
        &self,
        lpmessage: windows_core::Ref<'_, IMessage>,
        lpfolder: windows_core::Ref<'_, IMAPIFolder>,
        lpmdb: windows_core::Ref<'_, IMsgStore>,
        lpulflags: *mut u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut u8,
    ) -> windows_core::Result<()>;
    fn OutboundMsgHook(
        &self,
        lpmessage: windows_core::Ref<'_, IMessage>,
        lpfolder: windows_core::Ref<'_, IMAPIFolder>,
        lpmdb: windows_core::Ref<'_, IMsgStore>,
        lpulflags: *mut u32,
        lpcbentryid: *mut u32,
        lppentryid: *mut *mut u8,
    ) -> windows_core::Result<()>;
}
impl ISpoolerHook_Vtbl {
    pub const fn new<Identity: ISpoolerHook_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn InboundMsgHook<
            Identity: ISpoolerHook_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpmessage: *mut core::ffi::c_void,
            lpfolder: *mut core::ffi::c_void,
            lpmdb: *mut core::ffi::c_void,
            lpulflags: *mut u32,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                ISpoolerHook_Impl::InboundMsgHook(
                    this,
                    core::mem::transmute_copy(&lpmessage),
                    core::mem::transmute_copy(&lpfolder),
                    core::mem::transmute_copy(&lpmdb),
                    core::mem::transmute_copy(&lpulflags),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        unsafe extern "system" fn OutboundMsgHook<
            Identity: ISpoolerHook_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpmessage: *mut core::ffi::c_void,
            lpfolder: *mut core::ffi::c_void,
            lpmdb: *mut core::ffi::c_void,
            lpulflags: *mut u32,
            lpcbentryid: *mut u32,
            lppentryid: *mut *mut u8,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                ISpoolerHook_Impl::OutboundMsgHook(
                    this,
                    core::mem::transmute_copy(&lpmessage),
                    core::mem::transmute_copy(&lpfolder),
                    core::mem::transmute_copy(&lpmdb),
                    core::mem::transmute_copy(&lpulflags),
                    core::mem::transmute_copy(&lpcbentryid),
                    core::mem::transmute_copy(&lppentryid),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            InboundMsgHook: InboundMsgHook::<Identity, OFFSET>,
            OutboundMsgHook: OutboundMsgHook::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<ISpoolerHook as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for ISpoolerHook {}
pub const IStream_Clone: METHODS = METHODS(136i32);
pub const IStream_Commit: METHODS = METHODS(131i32);
pub const IStream_CopyTo: METHODS = METHODS(130i32);
pub const IStream_LockRegion: METHODS = METHODS(133i32);
pub const IStream_Revert: METHODS = METHODS(132i32);
pub const IStream_Seek: METHODS = METHODS(128i32);
pub const IStream_SetSize: METHODS = METHODS(129i32);
pub const IStream_Stat: METHODS = METHODS(135i32);
pub const IStream_UnlockRegion: METHODS = METHODS(134i32);
pub const IStream__Read: METHODS = METHODS(126i32);
pub const IStream__Write: METHODS = METHODS(127i32);
pub const ITEMPROC_FORCE: u32 = 2048u32;
pub const ITT_ENCRYPTION: u32 = 2u32;
pub const ITT_SIGNING: u32 = 1u32;
windows_core::imp::define_interface!(ITableData, ITableData_Vtbl, 0);
windows_core::imp::interface_hierarchy!(ITableData, windows_core::IUnknown);
impl ITableData {
    pub unsafe fn HrGetView(
        &self,
        lpssortorderset: *mut SSortOrderSet,
        lpfcallerrelease: *mut windows::Win32::System::AddressBook::CALLERRELEASE,
        ulcallerdata: usize,
        lppmapitable: *mut Option<IMAPITable>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HrGetView)(
                windows_core::Interface::as_raw(self),
                lpssortorderset as _,
                lpfcallerrelease as _,
                ulcallerdata,
                core::mem::transmute(lppmapitable),
            )
            .ok()
        }
    }
    pub unsafe fn HrModifyRow(&self, param0: *mut SRow) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HrModifyRow)(
                windows_core::Interface::as_raw(self),
                param0 as _,
            )
            .ok()
        }
    }
    pub unsafe fn HrDeleteRow(&self, lpspropvalue: *mut SPropValue) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HrDeleteRow)(
                windows_core::Interface::as_raw(self),
                lpspropvalue as _,
            )
            .ok()
        }
    }
    pub unsafe fn HrQueryRow(
        &self,
        lpspropvalue: *mut SPropValue,
        lppsrow: *mut *mut SRow,
        lpulirow: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HrQueryRow)(
                windows_core::Interface::as_raw(self),
                lpspropvalue as _,
                lppsrow as _,
                lpulirow as _,
            )
            .ok()
        }
    }
    pub unsafe fn HrEnumRow(
        &self,
        ulrownumber: u32,
        lppsrow: *mut *mut SRow,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HrEnumRow)(
                windows_core::Interface::as_raw(self),
                ulrownumber,
                lppsrow as _,
            )
            .ok()
        }
    }
    pub unsafe fn HrNotify(
        &self,
        ulflags: u32,
        cvalues: u32,
        lpspropvalue: *mut SPropValue,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HrNotify)(
                windows_core::Interface::as_raw(self),
                ulflags,
                cvalues,
                lpspropvalue as _,
            )
            .ok()
        }
    }
    pub unsafe fn HrInsertRow(&self, ulirow: u32, lpsrow: *mut SRow) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HrInsertRow)(
                windows_core::Interface::as_raw(self),
                ulirow,
                lpsrow as _,
            )
            .ok()
        }
    }
    pub unsafe fn HrModifyRows(
        &self,
        ulflags: u32,
        lpsrowset: *mut SRowSet,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HrModifyRows)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpsrowset as _,
            )
            .ok()
        }
    }
    pub unsafe fn HrDeleteRows(
        &self,
        ulflags: u32,
        lprowsettodelete: *mut SRowSet,
        crowsdeleted: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).HrDeleteRows)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lprowsettodelete as _,
                crowsdeleted as _,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct ITableData_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub HrGetView: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SSortOrderSet,
        *mut windows::Win32::System::AddressBook::CALLERRELEASE,
        usize,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub HrModifyRow:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut SRow) -> windows_core::HRESULT,
    pub HrDeleteRow:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut SPropValue) -> windows_core::HRESULT,
    pub HrQueryRow: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut SPropValue,
        *mut *mut SRow,
        *mut u32,
    ) -> windows_core::HRESULT,
    pub HrEnumRow: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut *mut SRow,
    ) -> windows_core::HRESULT,
    pub HrNotify: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        u32,
        *mut SPropValue,
    ) -> windows_core::HRESULT,
    pub HrInsertRow:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut SRow) -> windows_core::HRESULT,
    pub HrModifyRows: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut SRowSet,
    ) -> windows_core::HRESULT,
    pub HrDeleteRows: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut SRowSet,
        *mut u32,
    ) -> windows_core::HRESULT,
}
pub trait ITableData_Impl: windows_core::IUnknownImpl {
    fn HrGetView(
        &self,
        lpssortorderset: *mut SSortOrderSet,
        lpfcallerrelease: *mut windows::Win32::System::AddressBook::CALLERRELEASE,
        ulcallerdata: usize,
        lppmapitable: windows_core::OutRef<'_, IMAPITable>,
    ) -> windows_core::Result<()>;
    fn HrModifyRow(&self, param0: *mut SRow) -> windows_core::Result<()>;
    fn HrDeleteRow(&self, lpspropvalue: *mut SPropValue) -> windows_core::Result<()>;
    fn HrQueryRow(
        &self,
        lpspropvalue: *mut SPropValue,
        lppsrow: *mut *mut SRow,
        lpulirow: *mut u32,
    ) -> windows_core::Result<()>;
    fn HrEnumRow(&self, ulrownumber: u32, lppsrow: *mut *mut SRow) -> windows_core::Result<()>;
    fn HrNotify(
        &self,
        ulflags: u32,
        cvalues: u32,
        lpspropvalue: *mut SPropValue,
    ) -> windows_core::Result<()>;
    fn HrInsertRow(&self, ulirow: u32, lpsrow: *mut SRow) -> windows_core::Result<()>;
    fn HrModifyRows(&self, ulflags: u32, lpsrowset: *mut SRowSet) -> windows_core::Result<()>;
    fn HrDeleteRows(
        &self,
        ulflags: u32,
        lprowsettodelete: *mut SRowSet,
        crowsdeleted: *mut u32,
    ) -> windows_core::Result<()>;
}
impl ITableData_Vtbl {
    pub const fn new<Identity: ITableData_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn HrGetView<Identity: ITableData_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpssortorderset: *mut SSortOrderSet,
            lpfcallerrelease: *mut windows::Win32::System::AddressBook::CALLERRELEASE,
            ulcallerdata: usize,
            lppmapitable: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                ITableData_Impl::HrGetView(
                    this,
                    core::mem::transmute_copy(&lpssortorderset),
                    core::mem::transmute_copy(&lpfcallerrelease),
                    core::mem::transmute_copy(&ulcallerdata),
                    core::mem::transmute_copy(&lppmapitable),
                )
                .into()
            }
        }
        unsafe extern "system" fn HrModifyRow<Identity: ITableData_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            param0: *mut SRow,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                ITableData_Impl::HrModifyRow(this, core::mem::transmute_copy(&param0)).into()
            }
        }
        unsafe extern "system" fn HrDeleteRow<Identity: ITableData_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpspropvalue: *mut SPropValue,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                ITableData_Impl::HrDeleteRow(this, core::mem::transmute_copy(&lpspropvalue)).into()
            }
        }
        unsafe extern "system" fn HrQueryRow<Identity: ITableData_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpspropvalue: *mut SPropValue,
            lppsrow: *mut *mut SRow,
            lpulirow: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                ITableData_Impl::HrQueryRow(
                    this,
                    core::mem::transmute_copy(&lpspropvalue),
                    core::mem::transmute_copy(&lppsrow),
                    core::mem::transmute_copy(&lpulirow),
                )
                .into()
            }
        }
        unsafe extern "system" fn HrEnumRow<Identity: ITableData_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulrownumber: u32,
            lppsrow: *mut *mut SRow,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                ITableData_Impl::HrEnumRow(
                    this,
                    core::mem::transmute_copy(&ulrownumber),
                    core::mem::transmute_copy(&lppsrow),
                )
                .into()
            }
        }
        unsafe extern "system" fn HrNotify<Identity: ITableData_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            cvalues: u32,
            lpspropvalue: *mut SPropValue,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                ITableData_Impl::HrNotify(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&cvalues),
                    core::mem::transmute_copy(&lpspropvalue),
                )
                .into()
            }
        }
        unsafe extern "system" fn HrInsertRow<Identity: ITableData_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulirow: u32,
            lpsrow: *mut SRow,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                ITableData_Impl::HrInsertRow(
                    this,
                    core::mem::transmute_copy(&ulirow),
                    core::mem::transmute_copy(&lpsrow),
                )
                .into()
            }
        }
        unsafe extern "system" fn HrModifyRows<Identity: ITableData_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpsrowset: *mut SRowSet,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                ITableData_Impl::HrModifyRows(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpsrowset),
                )
                .into()
            }
        }
        unsafe extern "system" fn HrDeleteRows<Identity: ITableData_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lprowsettodelete: *mut SRowSet,
            crowsdeleted: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                ITableData_Impl::HrDeleteRows(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lprowsettodelete),
                    core::mem::transmute_copy(&crowsdeleted),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            HrGetView: HrGetView::<Identity, OFFSET>,
            HrModifyRow: HrModifyRow::<Identity, OFFSET>,
            HrDeleteRow: HrDeleteRow::<Identity, OFFSET>,
            HrQueryRow: HrQueryRow::<Identity, OFFSET>,
            HrEnumRow: HrEnumRow::<Identity, OFFSET>,
            HrNotify: HrNotify::<Identity, OFFSET>,
            HrInsertRow: HrInsertRow::<Identity, OFFSET>,
            HrModifyRows: HrModifyRows::<Identity, OFFSET>,
            HrDeleteRows: HrDeleteRows::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<ITableData as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for ITableData {}
pub const IUnknown_AddRef: METHODS = METHODS(1i32);
pub const IUnknown_QueryInterface: METHODS = METHODS(0i32);
pub const IUnknown_Release: METHODS = METHODS(2i32);
windows_core::imp::define_interface!(
    IXPLogon,
    IXPLogon_Vtbl,
    0x00020315_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IXPLogon, windows_core::IUnknown);
impl IXPLogon {
    pub unsafe fn AddressTypes(
        &self,
        lpulflags: *mut u32,
        lpcadrtype: *mut u32,
        lpppadrtypearray: *mut *mut *mut i8,
        lpcmapiuid: *mut u32,
        lpppuidarray: *mut *mut *mut MAPIUID,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).AddressTypes)(
                windows_core::Interface::as_raw(self),
                lpulflags as _,
                lpcadrtype as _,
                lpppadrtypearray as _,
                lpcmapiuid as _,
                lpppuidarray as _,
            )
            .ok()
        }
    }
    pub unsafe fn RegisterOptions(
        &self,
        lpulflags: *mut u32,
        lpcoptions: *mut u32,
        lppoptions: *mut *mut OPTIONDATA,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).RegisterOptions)(
                windows_core::Interface::as_raw(self),
                lpulflags as _,
                lpcoptions as _,
                lppoptions as _,
            )
            .ok()
        }
    }
    pub unsafe fn TransportNotify(
        &self,
        lpulflags: *mut u32,
        lppvdata: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).TransportNotify)(
                windows_core::Interface::as_raw(self),
                lpulflags as _,
                lppvdata as _,
            )
            .ok()
        }
    }
    pub unsafe fn Idle(&self, ulflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Idle)(
                windows_core::Interface::as_raw(self),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn TransportLogoff(&self, ulflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).TransportLogoff)(
                windows_core::Interface::as_raw(self),
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn SubmitMessage<P1>(
        &self,
        ulflags: u32,
        lpmessage: P1,
        lpulmsgref: *mut usize,
        lpulreturnparm: *mut usize,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).SubmitMessage)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpmessage.param().abi(),
                lpulmsgref as _,
                lpulreturnparm as _,
            )
            .ok()
        }
    }
    pub unsafe fn EndMessage(
        &self,
        ulmsgref: usize,
        lpulflags: *mut u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).EndMessage)(
                windows_core::Interface::as_raw(self),
                ulmsgref,
                lpulflags as _,
            )
            .ok()
        }
    }
    pub unsafe fn Poll(&self, lpulincoming: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Poll)(
                windows_core::Interface::as_raw(self),
                lpulincoming as _,
            )
            .ok()
        }
    }
    pub unsafe fn StartMessage<P1>(
        &self,
        ulflags: u32,
        lpmessage: P1,
        lpulmsgref: *mut usize,
    ) -> windows_core::Result<()>
    where
        P1: windows_core::Param<IMessage>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).StartMessage)(
                windows_core::Interface::as_raw(self),
                ulflags,
                lpmessage.param().abi(),
                lpulmsgref as _,
            )
            .ok()
        }
    }
    pub unsafe fn OpenStatusEntry(
        &self,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppentry: *mut Option<IMAPIStatus>,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).OpenStatusEntry)(
                windows_core::Interface::as_raw(self),
                lpinterface as _,
                ulflags,
                lpulobjtype as _,
                core::mem::transmute(lppentry),
            )
            .ok()
        }
    }
    pub unsafe fn ValidateState(&self, uluiparam: usize, ulflags: u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).ValidateState)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                ulflags,
            )
            .ok()
        }
    }
    pub unsafe fn FlushQueues(
        &self,
        uluiparam: usize,
        cbtargettransport: u32,
        lptargettransport: *mut ENTRYID,
        ulflags: u32,
    ) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).FlushQueues)(
                windows_core::Interface::as_raw(self),
                uluiparam,
                cbtargettransport,
                lptargettransport as _,
                ulflags,
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IXPLogon_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub AddressTypes: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut u32,
        *mut u32,
        *mut *mut *mut i8,
        *mut u32,
        *mut *mut *mut MAPIUID,
    ) -> windows_core::HRESULT,
    pub RegisterOptions: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut u32,
        *mut u32,
        *mut *mut OPTIONDATA,
    ) -> windows_core::HRESULT,
    pub TransportNotify: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub Idle: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub TransportLogoff:
        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
    pub SubmitMessage: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
        *mut usize,
        *mut usize,
    ) -> windows_core::HRESULT,
    pub EndMessage:
        unsafe extern "system" fn(*mut core::ffi::c_void, usize, *mut u32) -> windows_core::HRESULT,
    pub Poll: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub StartMessage: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        u32,
        *mut core::ffi::c_void,
        *mut usize,
    ) -> windows_core::HRESULT,
    pub OpenStatusEntry: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut windows_core::GUID,
        u32,
        *mut u32,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
    pub ValidateState:
        unsafe extern "system" fn(*mut core::ffi::c_void, usize, u32) -> windows_core::HRESULT,
    pub FlushQueues: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        usize,
        u32,
        *mut ENTRYID,
        u32,
    ) -> windows_core::HRESULT,
}
pub trait IXPLogon_Impl: windows_core::IUnknownImpl {
    fn AddressTypes(
        &self,
        lpulflags: *mut u32,
        lpcadrtype: *mut u32,
        lpppadrtypearray: *mut *mut *mut i8,
        lpcmapiuid: *mut u32,
        lpppuidarray: *mut *mut *mut MAPIUID,
    ) -> windows_core::Result<()>;
    fn RegisterOptions(
        &self,
        lpulflags: *mut u32,
        lpcoptions: *mut u32,
        lppoptions: *mut *mut OPTIONDATA,
    ) -> windows_core::Result<()>;
    fn TransportNotify(
        &self,
        lpulflags: *mut u32,
        lppvdata: *mut *mut core::ffi::c_void,
    ) -> windows_core::Result<()>;
    fn Idle(&self, ulflags: u32) -> windows_core::Result<()>;
    fn TransportLogoff(&self, ulflags: u32) -> windows_core::Result<()>;
    fn SubmitMessage(
        &self,
        ulflags: u32,
        lpmessage: windows_core::Ref<'_, IMessage>,
        lpulmsgref: *mut usize,
        lpulreturnparm: *mut usize,
    ) -> windows_core::Result<()>;
    fn EndMessage(&self, ulmsgref: usize, lpulflags: *mut u32) -> windows_core::Result<()>;
    fn Poll(&self, lpulincoming: *mut u32) -> windows_core::Result<()>;
    fn StartMessage(
        &self,
        ulflags: u32,
        lpmessage: windows_core::Ref<'_, IMessage>,
        lpulmsgref: *mut usize,
    ) -> windows_core::Result<()>;
    fn OpenStatusEntry(
        &self,
        lpinterface: *mut windows_core::GUID,
        ulflags: u32,
        lpulobjtype: *mut u32,
        lppentry: windows_core::OutRef<'_, IMAPIStatus>,
    ) -> windows_core::Result<()>;
    fn ValidateState(&self, uluiparam: usize, ulflags: u32) -> windows_core::Result<()>;
    fn FlushQueues(
        &self,
        uluiparam: usize,
        cbtargettransport: u32,
        lptargettransport: *mut ENTRYID,
        ulflags: u32,
    ) -> windows_core::Result<()>;
}
impl IXPLogon_Vtbl {
    pub const fn new<Identity: IXPLogon_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn AddressTypes<Identity: IXPLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulflags: *mut u32,
            lpcadrtype: *mut u32,
            lpppadrtypearray: *mut *mut *mut i8,
            lpcmapiuid: *mut u32,
            lpppuidarray: *mut *mut *mut MAPIUID,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPLogon_Impl::AddressTypes(
                    this,
                    core::mem::transmute_copy(&lpulflags),
                    core::mem::transmute_copy(&lpcadrtype),
                    core::mem::transmute_copy(&lpppadrtypearray),
                    core::mem::transmute_copy(&lpcmapiuid),
                    core::mem::transmute_copy(&lpppuidarray),
                )
                .into()
            }
        }
        unsafe extern "system" fn RegisterOptions<Identity: IXPLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulflags: *mut u32,
            lpcoptions: *mut u32,
            lppoptions: *mut *mut OPTIONDATA,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPLogon_Impl::RegisterOptions(
                    this,
                    core::mem::transmute_copy(&lpulflags),
                    core::mem::transmute_copy(&lpcoptions),
                    core::mem::transmute_copy(&lppoptions),
                )
                .into()
            }
        }
        unsafe extern "system" fn TransportNotify<Identity: IXPLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulflags: *mut u32,
            lppvdata: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPLogon_Impl::TransportNotify(
                    this,
                    core::mem::transmute_copy(&lpulflags),
                    core::mem::transmute_copy(&lppvdata),
                )
                .into()
            }
        }
        unsafe extern "system" fn Idle<Identity: IXPLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPLogon_Impl::Idle(this, core::mem::transmute_copy(&ulflags)).into()
            }
        }
        unsafe extern "system" fn TransportLogoff<Identity: IXPLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPLogon_Impl::TransportLogoff(this, core::mem::transmute_copy(&ulflags)).into()
            }
        }
        unsafe extern "system" fn SubmitMessage<Identity: IXPLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpmessage: *mut core::ffi::c_void,
            lpulmsgref: *mut usize,
            lpulreturnparm: *mut usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPLogon_Impl::SubmitMessage(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpmessage),
                    core::mem::transmute_copy(&lpulmsgref),
                    core::mem::transmute_copy(&lpulreturnparm),
                )
                .into()
            }
        }
        unsafe extern "system" fn EndMessage<Identity: IXPLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulmsgref: usize,
            lpulflags: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPLogon_Impl::EndMessage(
                    this,
                    core::mem::transmute_copy(&ulmsgref),
                    core::mem::transmute_copy(&lpulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn Poll<Identity: IXPLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulincoming: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPLogon_Impl::Poll(this, core::mem::transmute_copy(&lpulincoming)).into()
            }
        }
        unsafe extern "system" fn StartMessage<Identity: IXPLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            ulflags: u32,
            lpmessage: *mut core::ffi::c_void,
            lpulmsgref: *mut usize,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPLogon_Impl::StartMessage(
                    this,
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpmessage),
                    core::mem::transmute_copy(&lpulmsgref),
                )
                .into()
            }
        }
        unsafe extern "system" fn OpenStatusEntry<Identity: IXPLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpinterface: *mut windows_core::GUID,
            ulflags: u32,
            lpulobjtype: *mut u32,
            lppentry: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPLogon_Impl::OpenStatusEntry(
                    this,
                    core::mem::transmute_copy(&lpinterface),
                    core::mem::transmute_copy(&ulflags),
                    core::mem::transmute_copy(&lpulobjtype),
                    core::mem::transmute_copy(&lppentry),
                )
                .into()
            }
        }
        unsafe extern "system" fn ValidateState<Identity: IXPLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPLogon_Impl::ValidateState(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        unsafe extern "system" fn FlushQueues<Identity: IXPLogon_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            uluiparam: usize,
            cbtargettransport: u32,
            lptargettransport: *mut ENTRYID,
            ulflags: u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPLogon_Impl::FlushQueues(
                    this,
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&cbtargettransport),
                    core::mem::transmute_copy(&lptargettransport),
                    core::mem::transmute_copy(&ulflags),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            AddressTypes: AddressTypes::<Identity, OFFSET>,
            RegisterOptions: RegisterOptions::<Identity, OFFSET>,
            TransportNotify: TransportNotify::<Identity, OFFSET>,
            Idle: Idle::<Identity, OFFSET>,
            TransportLogoff: TransportLogoff::<Identity, OFFSET>,
            SubmitMessage: SubmitMessage::<Identity, OFFSET>,
            EndMessage: EndMessage::<Identity, OFFSET>,
            Poll: Poll::<Identity, OFFSET>,
            StartMessage: StartMessage::<Identity, OFFSET>,
            OpenStatusEntry: OpenStatusEntry::<Identity, OFFSET>,
            ValidateState: ValidateState::<Identity, OFFSET>,
            FlushQueues: FlushQueues::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXPLogon as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IXPLogon {}
pub const IXPLogon_AddressTypes: METHODS = METHODS(96i32);
pub const IXPLogon_EndMessage: METHODS = METHODS(102i32);
pub const IXPLogon_FlushQueues: METHODS = METHODS(107i32);
pub const IXPLogon_Idle: METHODS = METHODS(99i32);
pub const IXPLogon_OpenStatusEntry: METHODS = METHODS(105i32);
pub const IXPLogon_Poll: METHODS = METHODS(103i32);
pub const IXPLogon_RegisterOptions: METHODS = METHODS(97i32);
pub const IXPLogon_StartMessage: METHODS = METHODS(104i32);
pub const IXPLogon_SubmitMessage: METHODS = METHODS(101i32);
pub const IXPLogon_TransportLogoff: METHODS = METHODS(100i32);
pub const IXPLogon_TransportNotify: METHODS = METHODS(98i32);
pub const IXPLogon_ValidateState: METHODS = METHODS(106i32);
windows_core::imp::define_interface!(
    IXPProvider,
    IXPProvider_Vtbl,
    0x00020312_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IXPProvider, windows_core::IUnknown);
impl IXPProvider {
    pub unsafe fn Shutdown(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
        unsafe {
            (windows_core::Interface::vtable(self).Shutdown)(
                windows_core::Interface::as_raw(self),
                lpulflags as _,
            )
            .ok()
        }
    }
    pub unsafe fn TransportLogon<P0>(
        &self,
        lpmapisup: P0,
        uluiparam: usize,
        lpszprofilename: *const i8,
        lpulflags: *mut u32,
        lppmapierror: *mut *mut MAPIERROR,
        lppxplogon: *mut Option<IXPLogon>,
    ) -> windows_core::Result<()>
    where
        P0: windows_core::Param<IMAPISupport>,
    {
        unsafe {
            (windows_core::Interface::vtable(self).TransportLogon)(
                windows_core::Interface::as_raw(self),
                lpmapisup.param().abi(),
                uluiparam,
                lpszprofilename,
                lpulflags as _,
                lppmapierror as _,
                core::mem::transmute(lppxplogon),
            )
            .ok()
        }
    }
}
#[repr(C)]
pub struct IXPProvider_Vtbl {
    pub base__: windows_core::IUnknown_Vtbl,
    pub Shutdown:
        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
    pub TransportLogon: unsafe extern "system" fn(
        *mut core::ffi::c_void,
        *mut core::ffi::c_void,
        usize,
        *const i8,
        *mut u32,
        *mut *mut MAPIERROR,
        *mut *mut core::ffi::c_void,
    ) -> windows_core::HRESULT,
}
pub trait IXPProvider_Impl: windows_core::IUnknownImpl {
    fn Shutdown(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
    fn TransportLogon(
        &self,
        lpmapisup: windows_core::Ref<'_, IMAPISupport>,
        uluiparam: usize,
        lpszprofilename: *const i8,
        lpulflags: *mut u32,
        lppmapierror: *mut *mut MAPIERROR,
        lppxplogon: windows_core::OutRef<'_, IXPLogon>,
    ) -> windows_core::Result<()>;
}
impl IXPProvider_Vtbl {
    pub const fn new<Identity: IXPProvider_Impl, const OFFSET: isize>() -> Self {
        unsafe extern "system" fn Shutdown<Identity: IXPProvider_Impl, const OFFSET: isize>(
            this: *mut core::ffi::c_void,
            lpulflags: *mut u32,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPProvider_Impl::Shutdown(this, core::mem::transmute_copy(&lpulflags)).into()
            }
        }
        unsafe extern "system" fn TransportLogon<
            Identity: IXPProvider_Impl,
            const OFFSET: isize,
        >(
            this: *mut core::ffi::c_void,
            lpmapisup: *mut core::ffi::c_void,
            uluiparam: usize,
            lpszprofilename: *const i8,
            lpulflags: *mut u32,
            lppmapierror: *mut *mut MAPIERROR,
            lppxplogon: *mut *mut core::ffi::c_void,
        ) -> windows_core::HRESULT {
            unsafe {
                let this: &Identity =
                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
                IXPProvider_Impl::TransportLogon(
                    this,
                    core::mem::transmute_copy(&lpmapisup),
                    core::mem::transmute_copy(&uluiparam),
                    core::mem::transmute_copy(&lpszprofilename),
                    core::mem::transmute_copy(&lpulflags),
                    core::mem::transmute_copy(&lppmapierror),
                    core::mem::transmute_copy(&lppxplogon),
                )
                .into()
            }
        }
        Self {
            base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
            Shutdown: Shutdown::<Identity, OFFSET>,
            TransportLogon: TransportLogon::<Identity, OFFSET>,
        }
    }
    pub fn matches(iid: &windows_core::GUID) -> bool {
        iid == &<IXPProvider as windows_core::Interface>::IID
    }
}
impl windows_core::RuntimeName for IXPProvider {}
pub const IXPProvider_Shutdown: METHODS = METHODS(94i32);
pub const IXPProvider_TransportLogon: METHODS = METHODS(95i32);
pub const KEEP_OPEN_READONLY: u32 = 1u32;
pub const KEEP_OPEN_READWRITE: u32 = 2u32;
pub type LAUNCHWIZARDENTRY = Option<
    unsafe extern "system" fn(
        hparentwnd: windows::Win32::Foundation::HWND,
        ulflags: u32,
        lppszservicenametoadd: *mut *mut i8,
        cbbuffermax: u32,
        lpsznewprofilename: *mut i8,
    ) -> windows_core::HRESULT,
>;
pub const LAUNCHWIZARDENTRYNAME: windows_core::PCSTR = windows_core::s!("LAUNCHWIZARD");
pub const LIBID_MIMEOLE: windows_core::GUID =
    windows_core::GUID::from_u128(0xe4b28371_83b0_11d0_8259_00c04fd85ab4);
pub const LOCK_BLOCKING_MID_LOCK: u32 = 2u32;
pub const LOCK_NON_PERSISTENT: u32 = 1u32;
pub const LOCK_NULL_RESOURCE: u32 = 4u32;
pub const LOCK_READ_ACCESS_CHECK_ONLY: u32 = 8u32;
pub const LOCK_RESERVED: u32 = 2147483648u32;
pub const LOCK_WRITE_THROUGH_GOP: u32 = 65536u32;
pub const LOGOFF_ABORT: u32 = 8u32;
pub const LOGOFF_COMPLETE: u32 = 65536u32;
pub const LOGOFF_HURRY: u32 = 2147483648u32;
pub const LOGOFF_INBOUND: u32 = 131072u32;
pub const LOGOFF_NORMAL: u32 = 1u32;
pub const LOGOFF_NO_WAIT: u32 = 1u32;
pub const LOGOFF_ORDERLY: u32 = 2u32;
pub const LOGOFF_OUTBOUND: u32 = 262144u32;
pub const LOGOFF_OUTBOUND_QUEUE: u32 = 524288u32;
pub const LOGOFF_PURGE: u32 = 4u32;
pub const LOGOFF_QUIET: u32 = 16u32;
pub const LOGON_CHANGED: u32 = 8u32;
pub const LOGON_NO_CONNECT: u32 = 4u32;
pub const LOGON_NO_DIALOG: u32 = 1u32;
pub const LOGON_NO_INBOUND: u32 = 8u32;
pub const LOGON_NO_OUTBOUND: u32 = 16u32;
pub const LOGON_SP_IDLE: u32 = 65536u32;
pub const LOGON_SP_NEWPW: u32 = 4u32;
pub const LOGON_SP_POLL: u32 = 131072u32;
pub const LOGON_SP_PROMPT: u32 = 2u32;
pub const LOGON_SP_RESOLVE: u32 = 262144u32;
pub const LOGON_SP_TRANSPORT: u32 = 1u32;
pub type LPALLOCATEBUFFER =
    Option<unsafe extern "system" fn(cbsize: u32, lppbuffer: *mut *mut core::ffi::c_void) -> i32>;
pub type LPALLOCATEMORE = Option<
    unsafe extern "system" fn(
        cbsize: u32,
        lpobject: *mut core::ffi::c_void,
        lppbuffer: *mut *mut core::ffi::c_void,
    ) -> i32,
>;
pub type LPCREATECONVERSATIONINDEX = Option<
    unsafe extern "system" fn(
        cbparent: u32,
        lpbparent: *mut u8,
        lpcbconvindex: *mut u32,
        lppbconvindex: *mut *mut u8,
    ) -> i32,
>;
pub type LPDISPATCHNOTIFICATIONS =
    Option<unsafe extern "system" fn(ulflags: u32) -> windows_core::HRESULT>;
pub type LPFGETCOMPONENTPATH = Option<unsafe extern "system" fn() -> windows_core::BOOL>;
pub type LPFNABSDI = Option<
    unsafe extern "system" fn(
        uluiparam: usize,
        lpvmsg: *mut core::ffi::c_void,
    ) -> windows_core::BOOL,
>;
pub type LPFNBUTTON = Option<
    unsafe extern "system" fn(
        uluiparam: usize,
        lpvcontext: *mut core::ffi::c_void,
        cbentryid: u32,
        lpselection: *mut ENTRYID,
        ulflags: u32,
    ) -> i32,
>;
pub type LPFNDISMISS =
    Option<unsafe extern "system" fn(uluiparam: usize, lpvcontext: *mut core::ffi::c_void)>;
pub type LPFREEBUFFER = Option<unsafe extern "system" fn(lpbuffer: *mut core::ffi::c_void) -> u32>;
pub type LPLAUNCHWIZARDENTRY = Option<unsafe extern "system" fn() -> windows_core::HRESULT>;
pub type LPMAPIADDRESS = Option<
    unsafe extern "system" fn(
        lhsession: usize,
        uluiparam: usize,
        lpszcaption: windows_core::PCSTR,
        neditfields: u32,
        lpszlabels: windows_core::PCSTR,
        nrecips: u32,
        lprecips: *mut MapiRecipDesc,
        flflags: u32,
        ulreserved: u32,
        lpnnewrecips: *mut u32,
        lppnewrecips: *mut *mut MapiRecipDesc,
    ) -> u32,
>;
pub type LPMAPIADMINPROFILES = Option<unsafe extern "system" fn() -> windows_core::HRESULT>;
pub type LPMAPIALLOCATEBUFFER = Option<unsafe extern "system" fn() -> i32>;
pub type LPMAPIALLOCATEMORE = Option<unsafe extern "system" fn() -> i32>;
pub type LPMAPIDELETEMAIL = Option<
    unsafe extern "system" fn(
        lhsession: usize,
        uluiparam: usize,
        lpszmessageid: windows_core::PCSTR,
        flflags: u32,
        ulreserved: u32,
    ) -> u32,
>;
pub type LPMAPIDETAILS = Option<
    unsafe extern "system" fn(
        lhsession: usize,
        uluiparam: usize,
        lprecip: *mut MapiRecipDesc,
        flflags: u32,
        ulreserved: u32,
    ) -> u32,
>;
pub type LPMAPIFINDNEXT = Option<
    unsafe extern "system" fn(
        lhsession: usize,
        uluiparam: usize,
        lpszmessagetype: windows_core::PCSTR,
        lpszseedmessageid: windows_core::PCSTR,
        flflags: u32,
        ulreserved: u32,
        lpszmessageid: windows_core::PCSTR,
    ) -> u32,
>;
pub type LPMAPIFREEBUFFER = Option<unsafe extern "system" fn() -> u32>;
pub type LPMAPIINITIALIZE = Option<unsafe extern "system" fn() -> windows_core::HRESULT>;
pub type LPMAPILOGOFF = Option<
    unsafe extern "system" fn(
        lhsession: usize,
        uluiparam: usize,
        flflags: u32,
        ulreserved: u32,
    ) -> u32,
>;
pub type LPMAPILOGON = Option<
    unsafe extern "system" fn(
        uluiparam: usize,
        lpszprofilename: windows_core::PCSTR,
        lpszpassword: windows_core::PCSTR,
        flflags: u32,
        ulreserved: u32,
        lplhsession: *mut usize,
    ) -> u32,
>;
pub type LPMAPILOGONEX = Option<unsafe extern "system" fn() -> windows_core::HRESULT>;
pub type LPMAPIREADMAIL = Option<
    unsafe extern "system" fn(
        lhsession: usize,
        uluiparam: usize,
        lpszmessageid: windows_core::PCSTR,
        flflags: u32,
        ulreserved: u32,
        lppmessage: *mut *mut MapiMessage,
    ) -> u32,
>;
pub type LPMAPIRESOLVENAME = Option<
    unsafe extern "system" fn(
        lhsession: usize,
        uluiparam: usize,
        lpszname: windows_core::PCSTR,
        flflags: u32,
        ulreserved: u32,
        lpprecip: *mut *mut MapiRecipDesc,
    ) -> u32,
>;
pub type LPMAPISAVEMAIL = Option<
    unsafe extern "system" fn(
        lhsession: usize,
        uluiparam: usize,
        lpmessage: *mut MapiMessage,
        flflags: u32,
        ulreserved: u32,
        lpszmessageid: windows_core::PCSTR,
    ) -> u32,
>;
pub type LPMAPISENDDOCUMENTS = Option<
    unsafe extern "system" fn(
        uluiparam: usize,
        lpszdelimchar: windows_core::PCSTR,
        lpszfilepaths: windows_core::PCSTR,
        lpszfilenames: windows_core::PCSTR,
        ulreserved: u32,
    ) -> u32,
>;
pub type LPMAPISENDMAIL = Option<
    unsafe extern "system" fn(
        lhsession: usize,
        uluiparam: usize,
        lpmessage: *mut MapiMessage,
        flflags: u32,
        ulreserved: u32,
    ) -> u32,
>;
pub type LPMAPIUNINITIALIZE = Option<unsafe extern "system" fn()>;
pub type LPMSGSERVICEENTRY = Option<unsafe extern "system" fn() -> windows_core::HRESULT>;
pub type LPNOTIFCALLBACK = Option<
    unsafe extern "system" fn(
        lpvcontext: *mut core::ffi::c_void,
        cnotification: u32,
        lpnotifications: *mut NOTIFICATION,
    ) -> i32,
>;
pub type LPOPENSTREAMONFILE = Option<
    unsafe extern "system" fn(
        lpallocatebuffer: LPALLOCATEBUFFER,
        lpfreebuffer: LPFREEBUFFER,
        ulflags: u32,
        lpszfilename: *const i8,
        lpszprefix: *const i8,
        lppstream: windows_core::OutRef<'_, windows::Win32::System::Com::IStream>,
    ) -> windows_core::HRESULT,
>;
pub type LPSERVICEWIZARDDLGPROC = Option<unsafe extern "system" fn() -> windows_core::BOOL>;
pub type LPWIZARDENTRY = Option<unsafe extern "system" fn() -> u32>;
pub type MAPIADMINPROFILES = Option<
    unsafe extern "system" fn(
        ulflags: u32,
        lppprofadmin: windows_core::OutRef<'_, IProfAdmin>,
    ) -> windows_core::HRESULT,
>;
pub type MAPIALLOCATEBUFFER =
    Option<unsafe extern "system" fn(cbsize: u32, lppbuffer: *mut *mut core::ffi::c_void) -> i32>;
pub type MAPIALLOCATEMORE = Option<
    unsafe extern "system" fn(
        cbsize: u32,
        lpobject: *mut core::ffi::c_void,
        lppbuffer: *mut *mut core::ffi::c_void,
    ) -> i32,
>;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MAPIERROR {
    pub ulVersion: u32,
    pub lpszError: *mut i8,
    pub lpszComponent: *mut i8,
    pub ulLowLevelError: u32,
    pub ulContext: u32,
}
impl Default for MAPIERROR {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const MAPIFORM_CPU_AXP: u32 = 3u32;
pub const MAPIFORM_CPU_M68: u32 = 5u32;
pub const MAPIFORM_CPU_MIP: u32 = 2u32;
pub const MAPIFORM_CPU_PPC: u32 = 4u32;
pub const MAPIFORM_CPU_X64: u32 = 6u32;
pub const MAPIFORM_CPU_X86: u32 = 1u32;
pub const MAPIFORM_EXACTMATCH: u32 = 32u32;
pub const MAPIFORM_INSTALL_DIALOG: u32 = 8u32;
pub const MAPIFORM_INSTALL_OVERWRITEONCONFLICT: u32 = 16u32;
pub const MAPIFORM_OS_MAC_7x: u32 = 4u32;
pub const MAPIFORM_OS_WINNT_35: u32 = 2u32;
pub const MAPIFORM_OS_WINNT_40: u32 = 5u32;
pub const MAPIFORM_OS_WINNT_50: u32 = 6u32;
pub const MAPIFORM_OS_WINNT_60: u32 = 7u32;
pub const MAPIFORM_OS_WIN_31: u32 = 1u32;
pub const MAPIFORM_OS_WIN_95: u32 = 3u32;
pub const MAPIFORM_SELECT_ALL_REGISTRIES: u32 = 0u32;
pub const MAPIFORM_SELECT_FOLDER_REGISTRY_ONLY: u32 = 1u32;
pub const MAPIFORM_SELECT_NON_FOLDER_REGISTRY_ONLY: u32 = 2u32;
pub type MAPIFREEBUFFER =
    Option<unsafe extern "system" fn(lpbuffer: *mut core::ffi::c_void) -> u32>;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MAPIINIT {
    pub ulVersion: u32,
    pub ulFlags: u32,
}
impl Default for MAPIINIT {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub type MAPIINITIALIZE =
    Option<unsafe extern "system" fn(lpmapiinit: *mut core::ffi::c_void) -> windows_core::HRESULT>;
pub type MAPILOGONEX = Option<
    unsafe extern "system" fn(
        uluiparam: usize,
        lpszprofilename: *const i8,
        lpszpassword: *const i8,
        ulflags: u32,
        lppsession: windows_core::OutRef<'_, IMAPISession>,
    ) -> windows_core::HRESULT,
>;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct MAPINAMEID {
    pub lpguid: *mut windows_core::GUID,
    pub ulKind: u32,
    pub Kind: MAPINAMEID_0,
}
impl Default for MAPINAMEID {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union MAPINAMEID_0 {
    pub lID_Reserved: isize,
    pub lID: i32,
    pub lpwstrName: windows_core::PWSTR,
}
impl Default for MAPINAMEID_0 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MAPIUID {
    pub ab: [u8; 16],
}
impl Default for MAPIUID {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub type MAPIUNINITIALIZE = Option<unsafe extern "system" fn()>;
pub const MAPI_AB: u32 = 34u32;
pub const MAPI_ABCONT: u32 = 4u32;
pub const MAPI_AB_NOMODIFY: u32 = 1024u32;
pub const MAPI_AB_PROVIDER: u32 = 35u32;
pub const MAPI_ACCESS_CREATE_ASSOCIATED: u32 = 32u32;
pub const MAPI_ACCESS_CREATE_CONTENTS: u32 = 16u32;
pub const MAPI_ACCESS_CREATE_HIERARCHY: u32 = 8u32;
pub const MAPI_ACCESS_DELETE: u32 = 4u32;
pub const MAPI_ACCESS_MODIFY: u32 = 1u32;
pub const MAPI_ACCESS_READ: u32 = 2u32;
pub const MAPI_ADDRBOOK: u32 = 2u32;
pub const MAPI_ALLOW_OTHERS: u32 = 8u32;
pub const MAPI_AMBIGUOUS: u32 = 1u32;
pub const MAPI_ASSOCIATED: u32 = 64u32;
pub const MAPI_ATTACH: u32 = 7u32;
pub const MAPI_BCC: u32 = 3u32;
pub const MAPI_BEST_ACCESS: u32 = 16u32;
pub const MAPI_BG_SESSION: u32 = 2097152u32;
pub const MAPI_BODY_AS_FILE: u32 = 512u32;
pub const MAPI_CACHE_ONLY: u32 = 16384u32;
pub const MAPI_CC: u32 = 2u32;
pub const MAPI_COMPOUND: u32 = 128u32;
pub const MAPI_CREATE: u32 = 2u32;
pub const MAPI_DECLINE_OK: u32 = 4u32;
pub const MAPI_DEFAULT_SERVICES: u32 = 1u32;
pub const MAPI_DEFAULT_STORE: u32 = 1u32;
pub const MAPI_DEFERRED_ERRORS: u32 = 8u32;
pub const MAPI_DIALOG: u32 = 8u32;
pub const MAPI_DIM: u32 = 1u32;
pub const MAPI_DISABLED: u32 = 1u32;
pub const MAPI_DISTLIST: u32 = 8u32;
pub const MAPI_ENABLED: u32 = 0u32;
pub const MAPI_ENVELOPE_ONLY: u32 = 64u32;
pub const MAPI_ERROR_VERSION: i32 = 0i32;
pub const MAPI_EXPLICIT_PROFILE: u32 = 16u32;
pub const MAPI_EXTENDED: u32 = 32u32;
pub const MAPI_EXTENDEDCALLBACKS: u32 = 1024u32;
pub const MAPI_E_ACCESS_DENIED: u32 = 6u32;
pub const MAPI_E_ACCOUNT_DISABLED: windows_core::HRESULT =
    windows_core::HRESULT(0x80040124_u32 as _);
pub const MAPI_E_AMBIGUOUS_RECIP: windows_core::HRESULT =
    windows_core::HRESULT(0x80040700_u32 as _);
pub const MAPI_E_AMBIGUOUS_RECIPIENT: u32 = 21u32;
pub const MAPI_E_AMBIG_RECIP: u32 = 21u32;
pub const MAPI_E_ATTACHMENT_NOT_FOUND: u32 = 11u32;
pub const MAPI_E_ATTACHMENT_OPEN_FAILURE: u32 = 12u32;
pub const MAPI_E_ATTACHMENT_WRITE_FAILURE: u32 = 13u32;
pub const MAPI_E_BAD_CHARWIDTH: windows_core::HRESULT = windows_core::HRESULT(0x80040103_u32 as _);
pub const MAPI_E_BAD_COLUMN: windows_core::HRESULT = windows_core::HRESULT(0x80040118_u32 as _);
pub const MAPI_E_BAD_RECIPTYPE: u32 = 15u32;
pub const MAPI_E_BAD_VALUE: windows_core::HRESULT = windows_core::HRESULT(0x80040301_u32 as _);
pub const MAPI_E_BUSY: windows_core::HRESULT = windows_core::HRESULT(0x8004010B_u32 as _);
pub const MAPI_E_CALL_FAILED: windows_core::HRESULT = windows_core::HRESULT(0x80004005_u32 as _);
pub const MAPI_E_CANCEL: windows_core::HRESULT = windows_core::HRESULT(0x80040501_u32 as _);
pub const MAPI_E_COLLISION: windows_core::HRESULT = windows_core::HRESULT(0x80040604_u32 as _);
pub const MAPI_E_COMPUTED: windows_core::HRESULT = windows_core::HRESULT(0x8004011A_u32 as _);
pub const MAPI_E_CORRUPT_DATA: windows_core::HRESULT = windows_core::HRESULT(0x8004011B_u32 as _);
pub const MAPI_E_CORRUPT_STORE: windows_core::HRESULT = windows_core::HRESULT(0x80040600_u32 as _);
pub const MAPI_E_DECLINE_COPY: windows_core::HRESULT = windows_core::HRESULT(0x80040306_u32 as _);
pub const MAPI_E_DISK_ERROR: windows_core::HRESULT = windows_core::HRESULT(0x80040116_u32 as _);
pub const MAPI_E_DISK_FULL: u32 = 4u32;
pub const MAPI_E_END_OF_SESSION: windows_core::HRESULT = windows_core::HRESULT(0x80040200_u32 as _);
pub const MAPI_E_EXTENDED_ERROR: windows_core::HRESULT = windows_core::HRESULT(0x80040119_u32 as _);
pub const MAPI_E_FAILONEPROVIDER: windows_core::HRESULT =
    windows_core::HRESULT(0x8004011D_u32 as _);
pub const MAPI_E_FAILURE: u32 = 2u32;
pub const MAPI_E_FOLDER_CYCLE: windows_core::HRESULT = windows_core::HRESULT(0x8004060B_u32 as _);
pub const MAPI_E_HAS_FOLDERS: windows_core::HRESULT = windows_core::HRESULT(0x80040609_u32 as _);
pub const MAPI_E_HAS_MESSAGES: windows_core::HRESULT = windows_core::HRESULT(0x8004060A_u32 as _);
pub const MAPI_E_INSUFFICIENT_MEMORY: u32 = 5u32;
pub const MAPI_E_INTERFACE_NOT_SUPPORTED: windows_core::HRESULT =
    windows_core::HRESULT(0x80004002_u32 as _);
pub const MAPI_E_INVALID_ACCESS_TIME: windows_core::HRESULT =
    windows_core::HRESULT(0x80040123_u32 as _);
pub const MAPI_E_INVALID_BOOKMARK: windows_core::HRESULT =
    windows_core::HRESULT(0x80040405_u32 as _);
pub const MAPI_E_INVALID_EDITFIELDS: u32 = 24u32;
pub const MAPI_E_INVALID_ENTRYID: windows_core::HRESULT =
    windows_core::HRESULT(0x80040107_u32 as _);
pub const MAPI_E_INVALID_MESSAGE: u32 = 17u32;
pub const MAPI_E_INVALID_OBJECT: windows_core::HRESULT = windows_core::HRESULT(0x80040108_u32 as _);
pub const MAPI_E_INVALID_PARAMETER: windows_core::HRESULT =
    windows_core::HRESULT(0x80070057_u32 as _);
pub const MAPI_E_INVALID_RECIPS: u32 = 25u32;
pub const MAPI_E_INVALID_SESSION: u32 = 19u32;
pub const MAPI_E_INVALID_TYPE: windows_core::HRESULT = windows_core::HRESULT(0x80040302_u32 as _);
pub const MAPI_E_INVALID_WORKSTATION_ACCOUNT: windows_core::HRESULT =
    windows_core::HRESULT(0x80040122_u32 as _);
pub const MAPI_E_LOGIN_FAILURE: u32 = 3u32;
pub const MAPI_E_LOGON_FAILED: windows_core::HRESULT = windows_core::HRESULT(0x80040111_u32 as _);
pub const MAPI_E_LOGON_FAILURE: u32 = 3u32;
pub const MAPI_E_MESSAGE_IN_USE: u32 = 22u32;
pub const MAPI_E_MISSING_REQUIRED_COLUMN: windows_core::HRESULT =
    windows_core::HRESULT(0x80040202_u32 as _);
pub const MAPI_E_NETWORK_ERROR: windows_core::HRESULT = windows_core::HRESULT(0x80040115_u32 as _);
pub const MAPI_E_NETWORK_FAILURE: u32 = 23u32;
pub const MAPI_E_NON_STANDARD: windows_core::HRESULT = windows_core::HRESULT(0x80040606_u32 as _);
pub const MAPI_E_NOT_ENOUGH_DISK: windows_core::HRESULT =
    windows_core::HRESULT(0x8004010D_u32 as _);
pub const MAPI_E_NOT_ENOUGH_MEMORY: windows_core::HRESULT =
    windows_core::HRESULT(0x8007000E_u32 as _);
pub const MAPI_E_NOT_ENOUGH_RESOURCES: windows_core::HRESULT =
    windows_core::HRESULT(0x8004010E_u32 as _);
pub const MAPI_E_NOT_FOUND: windows_core::HRESULT = windows_core::HRESULT(0x8004010F_u32 as _);
pub const MAPI_E_NOT_INITIALIZED: windows_core::HRESULT =
    windows_core::HRESULT(0x80040605_u32 as _);
pub const MAPI_E_NOT_IN_QUEUE: windows_core::HRESULT = windows_core::HRESULT(0x80040601_u32 as _);
pub const MAPI_E_NOT_ME: windows_core::HRESULT = windows_core::HRESULT(0x80040502_u32 as _);
pub const MAPI_E_NOT_SUPPORTED: u32 = 26u32;
pub const MAPI_E_NO_ACCESS: windows_core::HRESULT = windows_core::HRESULT(0x80070005_u32 as _);
pub const MAPI_E_NO_MESSAGES: u32 = 16u32;
pub const MAPI_E_NO_RECIPIENTS: windows_core::HRESULT = windows_core::HRESULT(0x80040607_u32 as _);
pub const MAPI_E_NO_SUPPORT: windows_core::HRESULT = windows_core::HRESULT(0x80040102_u32 as _);
pub const MAPI_E_NO_SUPPRESS: windows_core::HRESULT = windows_core::HRESULT(0x80040602_u32 as _);
pub const MAPI_E_OBJECT_CHANGED: windows_core::HRESULT = windows_core::HRESULT(0x80040109_u32 as _);
pub const MAPI_E_OBJECT_DELETED: windows_core::HRESULT = windows_core::HRESULT(0x8004010A_u32 as _);
pub const MAPI_E_PASSWORD_CHANGE_REQUIRED: windows_core::HRESULT =
    windows_core::HRESULT(0x80040120_u32 as _);
pub const MAPI_E_PASSWORD_EXPIRED: windows_core::HRESULT =
    windows_core::HRESULT(0x80040121_u32 as _);
pub const MAPI_E_SESSION_LIMIT: windows_core::HRESULT = windows_core::HRESULT(0x80040112_u32 as _);
pub const MAPI_E_STRING_TOO_LONG: windows_core::HRESULT =
    windows_core::HRESULT(0x80040105_u32 as _);
pub const MAPI_E_SUBMITTED: windows_core::HRESULT = windows_core::HRESULT(0x80040608_u32 as _);
pub const MAPI_E_TABLE_EMPTY: windows_core::HRESULT = windows_core::HRESULT(0x80040402_u32 as _);
pub const MAPI_E_TABLE_TOO_BIG: windows_core::HRESULT = windows_core::HRESULT(0x80040403_u32 as _);
pub const MAPI_E_TEXT_TOO_LARGE: u32 = 18u32;
pub const MAPI_E_TIMEOUT: windows_core::HRESULT = windows_core::HRESULT(0x80040401_u32 as _);
pub const MAPI_E_TOO_BIG: windows_core::HRESULT = windows_core::HRESULT(0x80040305_u32 as _);
pub const MAPI_E_TOO_COMPLEX: windows_core::HRESULT = windows_core::HRESULT(0x80040117_u32 as _);
pub const MAPI_E_TOO_MANY_FILES: u32 = 9u32;
pub const MAPI_E_TOO_MANY_RECIPIENTS: u32 = 10u32;
pub const MAPI_E_TOO_MANY_SESSIONS: u32 = 8u32;
pub const MAPI_E_TYPE_NOT_SUPPORTED: u32 = 20u32;
pub const MAPI_E_TYPE_NO_SUPPORT: windows_core::HRESULT =
    windows_core::HRESULT(0x80040303_u32 as _);
pub const MAPI_E_UNABLE_TO_ABORT: windows_core::HRESULT =
    windows_core::HRESULT(0x80040114_u32 as _);
pub const MAPI_E_UNABLE_TO_COMPLETE: windows_core::HRESULT =
    windows_core::HRESULT(0x80040400_u32 as _);
pub const MAPI_E_UNCONFIGURED: windows_core::HRESULT = windows_core::HRESULT(0x8004011C_u32 as _);
pub const MAPI_E_UNEXPECTED_ID: windows_core::HRESULT = windows_core::HRESULT(0x80040307_u32 as _);
pub const MAPI_E_UNEXPECTED_TYPE: windows_core::HRESULT =
    windows_core::HRESULT(0x80040304_u32 as _);
pub const MAPI_E_UNKNOWN_CPID: windows_core::HRESULT = windows_core::HRESULT(0x8004011E_u32 as _);
pub const MAPI_E_UNKNOWN_ENTRYID: windows_core::HRESULT =
    windows_core::HRESULT(0x80040201_u32 as _);
pub const MAPI_E_UNKNOWN_FLAGS: windows_core::HRESULT = windows_core::HRESULT(0x80040106_u32 as _);
pub const MAPI_E_UNKNOWN_LCID: windows_core::HRESULT = windows_core::HRESULT(0x8004011F_u32 as _);
pub const MAPI_E_UNKNOWN_RECIPIENT: u32 = 14u32;
pub const MAPI_E_USER_ABORT: u32 = 1u32;
pub const MAPI_E_USER_CANCEL: windows_core::HRESULT = windows_core::HRESULT(0x80040113_u32 as _);
pub const MAPI_E_VERSION: windows_core::HRESULT = windows_core::HRESULT(0x80040110_u32 as _);
pub const MAPI_E_WAIT: windows_core::HRESULT = windows_core::HRESULT(0x80040500_u32 as _);
pub const MAPI_FOLDER: u32 = 3u32;
pub const MAPI_FORCE_CREATE: u32 = 1u32;
pub const MAPI_FORCE_DOWNLOAD: u32 = 4096u32;
pub const MAPI_FORMINFO: u32 = 12u32;
pub const MAPI_FULL_IPM_TREE: u32 = 2u32;
pub const MAPI_GUARANTEE_FIFO: u32 = 256u32;
pub const MAPI_HOOK_PROVIDER: u32 = 40u32;
pub const MAPI_INIT_VERSION: u32 = 0u32;
pub const MAPI_LOGOFF_SHARED: u32 = 1u32;
pub const MAPI_LOGOFF_UI: u32 = 2u32;
pub const MAPI_LOGON_UI: u32 = 1u32;
pub const MAPI_LONG_MSGID: u32 = 16384u32;
pub const MAPI_MAILUSER: u32 = 6u32;
pub const MAPI_MESSAGE: u32 = 5u32;
pub const MAPI_MESSAGE_BEHAVIOR_FOLDER: u32 = 1u32;
pub const MAPI_MESSAGE_BEHAVIOR_IPM: u32 = 0u32;
pub const MAPI_MH_DP_ML: u32 = 3u32;
pub const MAPI_MH_DP_MS: u32 = 2u32;
pub const MAPI_MH_DP_OTHER_AU: u32 = 6u32;
pub const MAPI_MH_DP_PDAU: u32 = 4u32;
pub const MAPI_MH_DP_PDS_PATRON: u32 = 5u32;
pub const MAPI_MH_DP_PRIVATE_UA: u32 = 1u32;
pub const MAPI_MH_DP_PUBLIC_UA: u32 = 0u32;
pub const MAPI_MODIFY: u32 = 1u32;
pub const MAPI_MOVE: u32 = 1u32;
pub const MAPI_MULTITHREAD_NOTIFICATIONS: u32 = 1u32;
pub const MAPI_NEW_MESSAGE: u32 = 2u32;
pub const MAPI_NEW_SESSION: u32 = 2u32;
pub const MAPI_NON_READ: u32 = 1u32;
pub const MAPI_NOREPLACE: u32 = 2u32;
pub const MAPI_NOTRECIP: u32 = 64u32;
pub const MAPI_NOTRESERVED: u32 = 8u32;
pub const MAPI_NOW: u32 = 16u32;
pub const MAPI_NO_CACHE: u32 = 512u32;
pub const MAPI_NO_COINIT: u32 = 8u32;
pub const MAPI_NO_HBAR: u32 = 1u32;
pub const MAPI_NO_IDS: u32 = 2u32;
pub const MAPI_NO_MAIL: u32 = 32768u32;
pub const MAPI_NO_STRINGS: u32 = 1u32;
pub const MAPI_NO_VBAR: u32 = 2u32;
pub const MAPI_NT_SERVICE: u32 = 65536u32;
pub const MAPI_OLE: u32 = 1u32;
pub const MAPI_OLE_STATIC: u32 = 2u32;
pub const MAPI_ONE_OFF_NO_RICH_INFO: u32 = 1u32;
pub const MAPI_ONE_OFF_UNICODE: u32 = 32768u32;
pub const MAPI_ORIG: u32 = 0u32;
pub const MAPI_P1: u32 = 268435456u32;
pub const MAPI_PASSWORD_UI: u32 = 131072u32;
pub const MAPI_PEEK: u32 = 128u32;
pub const MAPI_POST_MESSAGE: u32 = 1u32;
pub const MAPI_PRIMARY_STORE: u32 = 4u32;
pub const MAPI_PROFILE_PROVIDER: u32 = 38u32;
pub const MAPI_PROFSECT: u32 = 9u32;
pub const MAPI_PW_ADD_SERVICE_ONLY: u32 = 4u32;
pub const MAPI_PW_FIRST_PROFILE: u32 = 1u32;
pub const MAPI_PW_HIDE_SERVICES_LIST: u32 = 16u32;
pub const MAPI_PW_LAUNCHED_BY_CONFIG: u32 = 2u32;
pub const MAPI_PW_PROVIDER_UI_ONLY: u32 = 8u32;
pub const MAPI_RECEIPT_REQUESTED: u32 = 2u32;
pub const MAPI_RESERVED1: u32 = 65536u32;
pub const MAPI_RESOLVED: u32 = 2u32;
pub const MAPI_SECONDARY_STORE: u32 = 5u32;
pub const MAPI_SEND_NO_RICH_INFO: u32 = 65536u32;
pub const MAPI_SENT: u32 = 4u32;
pub const MAPI_SERVICE_UI_ALWAYS: u32 = 8192u32;
pub const MAPI_SESSION: u32 = 11u32;
pub const MAPI_SHORTTERM: u32 = 128u32;
pub const MAPI_SIMPLE_STORE_PERMANENT: u32 = 3u32;
pub const MAPI_SIMPLE_STORE_TEMPORARY: u32 = 2u32;
pub const MAPI_SPOOLER: u32 = 37u32;
pub const MAPI_STATUS: u32 = 10u32;
pub const MAPI_STORE: u32 = 1u32;
pub const MAPI_STORE_PROVIDER: u32 = 33u32;
pub const MAPI_SUBMITTED: u32 = 2147483648u32;
pub const MAPI_SUBSYSTEM: u32 = 39u32;
pub const MAPI_SUPPRESS_ATTACH: u32 = 2048u32;
pub const MAPI_THISSESSION: u32 = 32u32;
pub const MAPI_TIMEOUT_SHORT: u32 = 1048576u32;
pub const MAPI_TO: u32 = 1u32;
pub const MAPI_TOP_LEVEL: u32 = 1u32;
pub const MAPI_TRANSPORT_PROVIDER: u32 = 36u32;
pub const MAPI_UNICODE: u32 = 2147483648u32;
pub const MAPI_UNREAD: u32 = 1u32;
pub const MAPI_UNREAD_ONLY: u32 = 32u32;
pub const MAPI_UNRESOLVED: u32 = 0u32;
pub const MAPI_USER_ABORT: u32 = 1u32;
pub const MAPI_USE_DEFAULT: u32 = 64u32;
pub const MAPI_W_APPROX_COUNT: windows_core::HRESULT = windows_core::HRESULT(0x40482_u32 as _);
pub const MAPI_W_CANCEL_MESSAGE: windows_core::HRESULT = windows_core::HRESULT(0x40580_u32 as _);
pub const MAPI_W_ERRORS_RETURNED: windows_core::HRESULT = windows_core::HRESULT(0x40380_u32 as _);
pub const MAPI_W_NO_SERVICE: windows_core::HRESULT = windows_core::HRESULT(0x40203_u32 as _);
pub const MAPI_W_PARTIAL_COMPLETION: windows_core::HRESULT =
    windows_core::HRESULT(0x40680_u32 as _);
pub const MAPI_W_POSITION_CHANGED: windows_core::HRESULT = windows_core::HRESULT(0x40481_u32 as _);
pub const MAX_ADMD_NAME_SIZ: u32 = 17u32;
pub const MAX_CBMAX_BODY_LINE: u32 = 4294967295u32;
pub const MAX_CBMAX_HEADER_LINE: u32 = 4294967295u32;
pub const MAX_COUNTRY_NAME_SIZ: u32 = 4u32;
pub const MAX_MTA_NAME_SIZ: u32 = 33u32;
pub const MAX_PATH: u32 = 260u32;
pub const MAX_PRMD_NAME_SIZ: u32 = 17u32;
pub const MDB_FOLDER_IPM: u32 = 1u32;
pub const MDB_FOLDER_NORMAL: u32 = 4u32;
pub const MDB_FOLDER_RULES: u32 = 8u32;
pub const MDB_FOLDER_SEARCH: u32 = 2u32;
pub const MDB_IPM: u32 = 32u32;
pub const MDB_LIMIT_BELOW: u32 = 1u32;
pub const MDB_LIMIT_DISABLED: u32 = 16u32;
pub const MDB_LIMIT_ISSUE_WARNING: u32 = 2u32;
pub const MDB_LIMIT_NO_CHECK: u32 = 8u32;
pub const MDB_LIMIT_PROHIBIT_SEND: u32 = 4u32;
pub const MDB_NON_IPM: u32 = 16u32;
pub const MDB_NO_DIALOG: u32 = 1u32;
pub const MDB_NO_MAIL: u32 = 128u32;
pub const MDB_ONLINE: u32 = 256u32;
pub const MDB_OPEN_MSG_NO_BLOCK: u32 = 32u32;
pub const MDB_QUOTA_NOQUOTA: u32 = 4294967295u32;
pub const MDB_SAVE_MSG_UNLOCK: u32 = 64u32;
pub const MDB_TEMPORARY: u32 = 32u32;
pub const MDB_WRITE: u32 = 4u32;
pub const MEBF_FORMATBARSEP: u32 = 4u32;
pub const MEBF_INNERCLIENTEDGE: u32 = 2u32;
pub const MEBF_NOSCROLL: u32 = 8u32;
pub const MEBF_OUTERCLIENTEDGE: u32 = 1u32;
pub const MECD_ENCODEFILEURLSONLY: u32 = 8u32;
pub const MECD_ENCODEIMAGES: u32 = 4u32;
pub const MECD_ENCODEPLUGINS: u32 = 64u32;
pub const MECD_ENCODESOUNDS: u32 = 16u32;
pub const MECD_ENCODEVIDEO: u32 = 32u32;
pub const MECD_HTML: u32 = 1u32;
pub const MECD_PLAINTEXT: u32 = 2u32;
pub const MECMDID_APPLYDOCUMENT: u32 = 19u32;
pub const MECMDID_BACKGROUNDCOLOR: u32 = 18u32;
pub const MECMDID_BACKGROUNDIMAGE: u32 = 15u32;
pub const MECMDID_BACKGROUNDSOUND: u32 = 21u32;
pub const MECMDID_CHARSET: u32 = 13u32;
pub const MECMDID_DIRTY: u32 = 1u32;
pub const MECMDID_DOWNGRADEPLAINTEXT: u32 = 5u32;
pub const MECMDID_EDITHTML: u32 = 4u32;
pub const MECMDID_EDITMODE: u32 = 12u32;
pub const MECMDID_EMPTY: u32 = 2u32;
pub const MECMDID_FORMATFONT: u32 = 10u32;
pub const MECMDID_FORMATPARAGRAPH: u32 = 26u32;
pub const MECMDID_INSERTBGSOUND: u32 = 22u32;
pub const MECMDID_INSERTHTML: u32 = 17u32;
pub const MECMDID_INSERTTEXT: u32 = 16u32;
pub const MECMDID_INSERTTEXTFILE: u32 = 8u32;
pub const MECMDID_PREVIEWFORMAT: u32 = 11u32;
pub const MECMDID_ROT13: u32 = 7u32;
pub const MECMDID_SAVEASSTATIONERY: u32 = 14u32;
pub const MECMDID_SAVEATTACHMENTS: u32 = 20u32;
pub const MECMDID_SETSOURCETAB: u32 = 24u32;
pub const MECMDID_SETTEXT: u32 = 6u32;
pub const MECMDID_SHOWSOURCETABS: u32 = 23u32;
pub const MECMDID_STYLE: u32 = 3u32;
pub const MECMDID_TABLINKS: u32 = 25u32;
pub const MECMDID_VIEWSOURCE: u32 = 9u32;
pub const MECMD_VS_HTML: u32 = 1u32;
pub const MECMD_VS_MESSAGE: u32 = 2u32;
pub const MEHEADER_FORCE_ENGLISH: u32 = 4u32;
pub const MEHEADER_MAIL: u32 = 2u32;
pub const MEHEADER_NEWS: u32 = 1u32;
pub const MEHEADER_NONE: u32 = 0u32;
pub const MEHOSTCMDID_ADD_TO_ADDRESSBOOK: u32 = 10u32;
pub const MEHOSTCMDID_ADD_TO_FAVORITES: u32 = 11u32;
pub const MEHOSTCMDID_BORDERFLAGS: u32 = 14u32;
pub const MEHOSTCMDID_COMPOSE_FONT: u32 = 9u32;
pub const MEHOSTCMDID_FLAGS: u32 = 6u32;
pub const MEHOSTCMDID_FONTCACHE: u32 = 13u32;
pub const MEHOSTCMDID_HEADER_TYPE: u32 = 4u32;
pub const MEHOSTCMDID_ONPARSECOMPLETE: u32 = 5u32;
pub const MEHOSTCMDID_QUOTE_CHAR: u32 = 7u32;
pub const MEHOSTCMDID_REPLY_TICK_COLOR: u32 = 8u32;
pub const MEHOSTCMDID_SAVEATTACH_PATH: u32 = 17u32;
pub const MEHOSTCMDID_SECURITY_ZONE: u32 = 15u32;
pub const MEHOSTCMDID_SIGNATURE: u32 = 3u32;
pub const MEHOSTCMDID_SIGNATURE_ENABLED: u32 = 1u32;
pub const MEHOSTCMDID_SIGNATURE_OPTIONS: u32 = 2u32;
pub const MEHOSTCMDID_SLIDESHOW_DELAY: u32 = 12u32;
pub const MEHOSTCMDID_SOURCEEDIT_FLAGS: u32 = 18u32;
pub const MEHOSTCMDID_SPELL_LANGUAGE: u32 = 19u32;
pub const MEHOSTCMDID_SPELL_OPTIONS: u32 = 16u32;
pub const MEO_FLAGS_AUTOINLINE: u32 = 4u32;
pub const MEO_FLAGS_AUTOTEXT: u32 = 16u32;
pub const MEO_FLAGS_BLOCKQUOTE: u32 = 32u32;
pub const MEO_FLAGS_DONTSPELLCHECKQUOTED: u32 = 128u32;
pub const MEO_FLAGS_HTML: u32 = 2u32;
pub const MEO_FLAGS_INCLUDEMSG: u32 = 1u32;
pub const MEO_FLAGS_SENDEXTERNALIMGSRC: u32 = 256u32;
pub const MEO_FLAGS_SENDIMAGES: u32 = 64u32;
pub const MEO_FLAGS_SLIDESHOW: u32 = 8u32;
pub const MESIGOPT_BOTTOM: u32 = 8u32;
pub const MESIGOPT_HTML: u32 = 16u32;
pub const MESIGOPT_PLAIN: u32 = 1u32;
pub const MESIGOPT_PREFIX: u32 = 4u32;
pub const MESIGOPT_TOP: u32 = 2u32;
pub const MESIG_AUTO: u32 = 1u32;
pub const MESIG_MANUAL: u32 = 2u32;
pub const MESPELLOPT_ALWAYSSUGGEST: u32 = 32u32;
pub const MESPELLOPT_CHECKONSEND: u32 = 64u32;
pub const MESPELLOPT_CHECKONTYPE: u32 = 128u32;
pub const MESPELLOPT_IGNOREDBCS: u32 = 4u32;
pub const MESPELLOPT_IGNORENUMBER: u32 = 1u32;
pub const MESPELLOPT_IGNOREPROTECT: u32 = 8u32;
pub const MESPELLOPT_IGNOREUPPER: u32 = 2u32;
pub const MESPELLOPT_IGNOREURL: u32 = 16u32;
pub const MESRCFLAGS_COLOR: u32 = 1u32;
pub const MESSAGE_BEST_BODY: u32 = 16u32;
pub const MESSAGE_DIALOG: u32 = 2u32;
pub const MESSAGE_MOVE: u32 = 1u32;
pub const MESSAGE_SEND_ENTRYID: u32 = 32u32;
pub const MESTYLE_FORMATBAR: u32 = 2u32;
pub const MESTYLE_MINIHEADER: u32 = 3u32;
pub const MESTYLE_NOHEADER: u32 = 0u32;
pub const MESTYLE_PREVIEW: u32 = 1u32;
pub const MEST_EDIT: u32 = 0u32;
pub const MEST_NEXT: u32 = 3u32;
pub const MEST_PREVIEW: u32 = 2u32;
pub const MEST_PREVIOUS: u32 = 4u32;
pub const MEST_SOURCE: u32 = 1u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct METHODS(pub i32);
pub const MIMEOLE_COMPAT_MLANG2: u32 = 2u32;
pub const MIMEOLE_COMPAT_OE5: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MIMEPARAMINFO {
    pub pszName: windows_core::PSTR,
    pub pszData: windows_core::PSTR,
}
impl Default for MIMEPARAMINFO {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct MIMEPROPFLAGS(pub i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct MIMEPROPID(pub i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MIMEPROPINFO {
    pub dwMask: u32,
    pub hCharset: *mut HCHARSET__,
    pub ietEncoding: ENCODINGTYPE,
    pub dwRowNumber: u32,
    pub dwFlags: u32,
    pub dwPropId: u32,
    pub cValues: u32,
    pub vtDefault: u16,
    pub vtCurrent: u16,
}
impl Default for MIMEPROPINFO {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct MIMESAVETYPE(pub i32);
pub const MIN_CBMAX_BODY_LINE: u32 = 30u32;
pub const MIN_CBMAX_HEADER_LINE: u32 = 76u32;
pub const MIN_EMS_AB_CONSTRUCTED_PROP_ID: u32 = 65528u32;
pub const MNID_ID: u32 = 0u32;
pub const MNID_STRING: u32 = 1u32;
pub const MODRECIP_ADD: u32 = 2u32;
pub const MODRECIP_MODIFY: u32 = 4u32;
pub const MODRECIP_REMOVE: u32 = 8u32;
pub const MPF_ADDRESS: MIMEPROPFLAGS = MIMEPROPFLAGS(4i32);
pub const MPF_HASPARAMS: MIMEPROPFLAGS = MIMEPROPFLAGS(8i32);
pub const MPF_INETCSET: MIMEPROPFLAGS = MIMEPROPFLAGS(1i32);
pub const MPF_MIME: MIMEPROPFLAGS = MIMEPROPFLAGS(16i32);
pub const MPF_READONLY: MIMEPROPFLAGS = MIMEPROPFLAGS(32i32);
pub const MPF_RFC1522: MIMEPROPFLAGS = MIMEPROPFLAGS(2i32);
pub const MSCAP_RES_ANNOTATION: u32 = 1u32;
pub const MSCAP_SECURE_FOLDER_HOMEPAGES: u32 = 1u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct MSCAP_SELECTOR(pub i32);
pub const MSCAP_SEL_FOLDER: MSCAP_SELECTOR = MSCAP_SELECTOR(2i32);
pub const MSCAP_SEL_RESERVED1: MSCAP_SELECTOR = MSCAP_SELECTOR(0i32);
pub const MSCAP_SEL_RESERVED2: MSCAP_SELECTOR = MSCAP_SELECTOR(1i32);
pub const MSCAP_SEL_RESERVED3: MSCAP_SELECTOR = MSCAP_SELECTOR(3i32);
pub const MSCAP_SEL_RESTRICTION: MSCAP_SELECTOR = MSCAP_SELECTOR(4i32);
pub type MSGCALLRELEASE = Option<
    unsafe extern "system" fn(ulcallerdata: u32, lpmessage: windows_core::Ref<'_, IMessage>),
>;
pub const MSGFLAG_ASSOCIATED: u32 = 64u32;
pub const MSGFLAG_FROMME: u32 = 32u32;
pub const MSGFLAG_HASATTACH: u32 = 16u32;
pub const MSGFLAG_NRN_PENDING: u32 = 512u32;
pub const MSGFLAG_READ: u32 = 1u32;
pub const MSGFLAG_RESEND: u32 = 128u32;
pub const MSGFLAG_RN_PENDING: u32 = 256u32;
pub const MSGFLAG_SUBMIT: u32 = 4u32;
pub const MSGFLAG_UNMODIFIED: u32 = 2u32;
pub const MSGFLAG_UNSENT: u32 = 8u32;
pub type MSGSERVICEENTRY = Option<
    unsafe extern "system" fn(
        hinstance: windows::Win32::Foundation::HINSTANCE,
        lpmalloc: windows_core::Ref<'_, windows::Win32::System::Com::IMalloc>,
        lpmapisup: windows_core::Ref<'_, IMAPISupport>,
        uluiparam: usize,
        ulflags: u32,
        ulcontext: u32,
        cvalues: u32,
        lpprops: *mut SPropValue,
        lpprovideradmin: windows_core::Ref<'_, IProviderAdmin>,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> windows_core::HRESULT,
>;
pub const MSGSTATUS_DELMARKED: u32 = 8u32;
pub const MSGSTATUS_HIDDEN: u32 = 4u32;
pub const MSGSTATUS_HIGHLIGHTED: u32 = 1u32;
pub const MSGSTATUS_IN_CONFLICT: u32 = 2048u32;
pub const MSGSTATUS_MDNSENT: u32 = 16384u32;
pub const MSGSTATUS_REMOTE_DELETE: u32 = 8192u32;
pub const MSGSTATUS_REMOTE_DOWNLOAD: u32 = 4096u32;
pub const MSGSTATUS_TAGGED: u32 = 2u32;
pub const MSG_LOCKED: u32 = 1u32;
pub const MSG_SERVICE_CONFIGURE: u32 = 3u32;
pub const MSG_SERVICE_CREATE: u32 = 2u32;
pub const MSG_SERVICE_DELETE: u32 = 4u32;
pub const MSG_SERVICE_INSTALL: u32 = 1u32;
pub const MSG_SERVICE_PROVIDER_CREATE: u32 = 6u32;
pub const MSG_SERVICE_PROVIDER_DELETE: u32 = 7u32;
pub const MSG_SERVICE_UI_READ_ONLY: u32 = 8u32;
pub const MSG_SERVICE_UNINSTALL: u32 = 5u32;
pub const MSG_UNLOCKED: u32 = 0u32;
pub type MSPROVIDERINIT = Option<
    unsafe extern "system" fn(
        hinstance: windows::Win32::Foundation::HINSTANCE,
        lpmalloc: windows_core::Ref<'_, windows::Win32::System::Com::IMalloc>,
        lpallocatebuffer: LPALLOCATEBUFFER,
        lpallocatemore: LPALLOCATEMORE,
        lpfreebuffer: LPFREEBUFFER,
        ulflags: u32,
        ulmapiver: u32,
        lpulproviderver: *mut u32,
        lppmsprovider: windows_core::OutRef<'_, IMSProvider>,
    ) -> windows_core::HRESULT,
>;
pub const MST_BLOB_FLAG: u32 = 4u32;
pub const MST_CHILD_ENCRYPT: u32 = 512u32;
pub const MST_CHILD_MASK: u32 = 3840u32;
pub const MST_CHILD_SIGN: u32 = 256u32;
pub const MST_CLASS_MASK: u32 = 4278190080u32;
pub const MST_CLASS_PGP: u32 = 16777216u32;
pub const MST_CLASS_SMIME_V1: u32 = 0u32;
pub const MST_DESCENDENT_MASK: u32 = 65280u32;
pub const MST_ENCRYPT_MASK: u32 = 8706u32;
pub const MST_NONE: u32 = 0u32;
pub const MST_RECEIPT_REQUEST: u32 = 65536u32;
pub const MST_SIGN_MASK: u32 = 4353u32;
pub const MST_SUBMSG_ENCRYPT: u32 = 8192u32;
pub const MST_SUBMSG_MASK: u32 = 61440u32;
pub const MST_SUBMSG_SIGN: u32 = 4096u32;
pub const MST_THIS_BLOBSIGN: u32 = 5u32;
pub const MST_THIS_ENCRYPT: u32 = 2u32;
pub const MST_THIS_MASK: u32 = 255u32;
pub const MST_THIS_SIGN: u32 = 1u32;
pub const MST_TYPE_MASK: u32 = 65535u32;
pub const MSV_BADSIGNATURE: u32 = 1u32;
pub const MSV_CANTDECRYPT: u32 = 4096u32;
pub const MSV_ENCRYPT_MASK: u32 = 1044480u32;
pub const MSV_ENC_FOR_EXPIREDCERT: u32 = 8192u32;
pub const MSV_EXPIRED_SIGNINGCERT: u32 = 256u32;
pub const MSV_INVALID: u32 = 16777216u32;
pub const MSV_MALFORMEDSIG: u32 = 128u32;
pub const MSV_MSG_MASK: u32 = 251658240u32;
pub const MSV_OK: u32 = 0u32;
pub const MSV_SIGNATURE_MASK: u32 = 255u32;
pub const MSV_SIGNING_MASK: u32 = 3840u32;
pub const MSV_UNKHASH: u32 = 4u32;
pub const MSV_UNVERIFIABLE: u32 = 2u32;
pub const MTA_PAD: u32 = 3u32;
pub const MTA_PAD_FOR_ACTIONS: u32 = 2u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MTSID {
    pub cb: u32,
    pub ab: [u8; 1],
}
impl Default for MTSID {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const MUID_PROFILE_INSTANCE: windows_core::GUID =
    windows_core::GUID::from_u128(0x00020385_0000_0000_c000_000000000046);
pub const MV_FLAG: u32 = 4096u32;
pub const MV_INSTANCE: u32 = 8192u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MapiFileDesc {
    pub ulReserved: u32,
    pub flFlags: u32,
    pub nPosition: u32,
    pub lpszPathName: windows_core::PSTR,
    pub lpszFileName: windows_core::PSTR,
    pub lpFileType: *mut core::ffi::c_void,
}
impl Default for MapiFileDesc {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MapiFileTagExt {
    pub ulReserved: u32,
    pub cbTag: u32,
    pub lpTag: *mut u8,
    pub cbEncoding: u32,
    pub lpEncoding: *mut u8,
}
impl Default for MapiFileTagExt {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MapiMessage {
    pub ulReserved: u32,
    pub lpszSubject: windows_core::PSTR,
    pub lpszNoteText: windows_core::PSTR,
    pub lpszMessageType: windows_core::PSTR,
    pub lpszDateReceived: windows_core::PSTR,
    pub lpszConversationID: windows_core::PSTR,
    pub flFlags: u32,
    pub lpOriginator: *mut MapiRecipDesc,
    pub nRecipCount: u32,
    pub lpRecips: *mut MapiRecipDesc,
    pub nFileCount: u32,
    pub lpFiles: *mut MapiFileDesc,
}
impl Default for MapiMessage {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MapiRecipDesc {
    pub ulReserved: u32,
    pub ulRecipClass: u32,
    pub lpszName: windows_core::PSTR,
    pub lpszAddress: windows_core::PSTR,
    pub ulEIDSize: u32,
    pub lpEntryID: *mut core::ffi::c_void,
}
impl Default for MapiRecipDesc {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const NEEDS_PREPROCESSING: u32 = 1u32;
pub const NEEDS_SPOOLER: u32 = 2u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct NEWMAIL_NOTIFICATION {
    pub cbEntryID: u32,
    pub lpEntryID: *mut ENTRYID,
    pub cbParentID: u32,
    pub lpParentID: *mut ENTRYID,
    pub ulFlags: u32,
    pub lpszMessageClass: *mut i8,
    pub ulMessageFlags: u32,
}
impl Default for NEWMAIL_NOTIFICATION {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const NOFLAGS: u32 = 0u32;
pub const NON_EMS_XP_SAVE: u32 = 4096u32;
pub const NON_STANDARD: u32 = 65536u32;
pub const NORM_IGNORECASE: u32 = 1u32;
pub const NORM_IGNOREKANATYPE: u32 = 65536u32;
pub const NORM_IGNORENONSPACE: u32 = 2u32;
pub const NORM_IGNORESYMBOLS: u32 = 4u32;
pub const NORM_IGNOREWIDTH: u32 = 131072u32;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct NOTIFICATION {
    pub ulEventType: u32,
    pub ulAlignPad: u32,
    pub info: NOTIFICATION_0,
}
impl Default for NOTIFICATION {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union NOTIFICATION_0 {
    pub err: ERROR_NOTIFICATION,
    pub newmail: NEWMAIL_NOTIFICATION,
    pub obj: OBJECT_NOTIFICATION,
    pub tab: TABLE_NOTIFICATION,
    pub ext: EXTENDED_NOTIFICATION,
    pub statobj: STATUS_OBJECT_NOTIFICATION,
}
impl Default for NOTIFICATION_0 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct NOTIFKEY {
    pub cb: u32,
    pub ab: [u8; 1],
}
impl Default for NOTIFKEY {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const NOTIFY_ABORT_DEFERRED: u32 = 1073741824u32;
pub const NOTIFY_ACCT_CHANGED: u32 = 1u32;
pub const NOTIFY_ACCT_CREATED: u32 = 2u32;
pub const NOTIFY_ACCT_DELETED: u32 = 3u32;
pub const NOTIFY_ACCT_ORDER_CHANGED: u32 = 4u32;
pub const NOTIFY_ACCT_PREDELETED: u32 = 5u32;
pub const NOTIFY_BEGIN_INBOUND: u32 = 1u32;
pub const NOTIFY_BEGIN_INBOUND_FLUSH: u32 = 4u32;
pub const NOTIFY_BEGIN_OUTBOUND: u32 = 2u32;
pub const NOTIFY_BEGIN_OUTBOUND_FLUSH: u32 = 8u32;
pub const NOTIFY_CANCELED: u32 = 2147483648u32;
pub const NOTIFY_CANCEL_MESSAGE: u32 = 2147483648u32;
pub const NOTIFY_CONFIG_CHANGE: u32 = 16384u32;
pub const NOTIFY_CRITICAL_ERROR: u32 = 268435456u32;
pub const NOTIFY_CRITSEC: u32 = 4096u32;
pub const NOTIFY_END_INBOUND: u32 = 65536u32;
pub const NOTIFY_END_INBOUND_FLUSH: u32 = 262144u32;
pub const NOTIFY_END_OUTBOUND: u32 = 131072u32;
pub const NOTIFY_END_OUTBOUND_FLUSH: u32 = 524288u32;
pub const NOTIFY_NEWMAIL: u32 = 1u32;
pub const NOTIFY_NEWMAIL_RECEIVED: u32 = 536870912u32;
pub const NOTIFY_NONCRIT: u32 = 8192u32;
pub const NOTIFY_READYTOSEND: u32 = 2u32;
pub const NOTIFY_SENTDEFERRED: u32 = 4u32;
pub const NOTIFY_SYNC: u32 = 1073741824u32;
pub const NO_ATTACHMENT: u32 = 0u32;
pub const NO_OST_DEFAULT: u32 = 0u32;
pub const NO_OST_FLAG_ALLOWED: u32 = 0u32;
pub const NO_OST_FLAG_CACHE_ONLY: u32 = 1u32;
pub const NO_OST_FLAG_NOT_ALLOWED: u32 = 2u32;
pub const NO_OST_FLAG_NO_CACHE: u32 = 3u32;
pub const NULL_RESTRICTION: u32 = 255u32;
pub const NUM_AG_TYPES: u32 = 3u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct OBJECT_NOTIFICATION {
    pub cbEntryID: u32,
    pub lpEntryID: *mut ENTRYID,
    pub ulObjType: u32,
    pub cbParentID: u32,
    pub lpParentID: *mut ENTRYID,
    pub cbOldID: u32,
    pub lpOldID: *mut ENTRYID,
    pub cbOldParentID: u32,
    pub lpOldParentID: *mut ENTRYID,
    pub lpPropTagArray: *mut SPropTagArray,
}
impl Default for OBJECT_NOTIFICATION {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const OF_AVAILABLE_OFFLINE: u32 = 1u32;
pub const OF_FORCE: u32 = 2147483648u32;
pub const OID: CERTNAMETYPE = CERTNAMETYPE(1i32);
pub const OID_ENCODING: u32 = 11u32;
pub const OID_TAG: u32 = 10u32;
pub const OLK_ACCOUNT_NO_FLAGS: u32 = 0u32;
pub const OPENSTORE_ALTERNATE_SERVER: u32 = 256u32;
pub const OPENSTORE_CACHE_EXCHANGE: u32 = 32768u32;
pub const OPENSTORE_CALLBACK_LOGON: u32 = 4096u32;
pub const OPENSTORE_CLI_WITH_NAMEDPROP_FIX: u32 = 65536u32;
pub const OPENSTORE_CLI_WITH_REPLID_GUID_MAPPING_FIX: u32 = 262144u32;
pub const OPENSTORE_ENABLE_LAZY_LOGGING: u32 = 131072u32;
pub const OPENSTORE_FAIL_IF_NO_MAILBOX: u32 = 16384u32;
pub const OPENSTORE_HOME_LOGON: u32 = 4u32;
pub const OPENSTORE_IGNORE_HOME_MDB: u32 = 512u32;
pub const OPENSTORE_INTERNET_ANONYMOUS: u32 = 128u32;
pub const OPENSTORE_LOCAL: u32 = 8192u32;
pub const OPENSTORE_NO_LOCALIZATION: u32 = 524288u32;
pub const OPENSTORE_NO_MAIL: u32 = 1024u32;
pub const OPENSTORE_OVERRIDE_HOME_MDB: u32 = 16u32;
pub const OPENSTORE_OVERRIDE_LAST_MODIFIER: u32 = 2048u32;
pub const OPENSTORE_PUBLIC: u32 = 2u32;
pub const OPENSTORE_REMOTE_TRANSPORT: u32 = 64u32;
pub const OPENSTORE_RESTORE_DATABASE: u32 = 1048576u32;
pub const OPENSTORE_TAKE_OWNERSHIP: u32 = 8u32;
pub const OPENSTORE_TRANSPORT: u32 = 32u32;
pub const OPENSTORE_USE_ADMIN_PRIVILEGE: u32 = 1u32;
pub const OPENSTORE_XFOREST_MOVE: u32 = 2097152u32;
pub const OPENSTREAMONFILE: windows_core::PCSTR = windows_core::s!("OpenStreamOnFile");
pub const OPEN_ALWAYS: u32 = 4u32;
pub const OPEN_EXISTING: u32 = 3u32;
pub const OPEN_IF_EXISTS: u32 = 1u32;
pub type OPTIONCALLBACK = Option<
    unsafe extern "system" fn(
        hinst: windows::Win32::Foundation::HINSTANCE,
        lpmalloc: windows_core::Ref<'_, windows::Win32::System::Com::IMalloc>,
        ulflags: u32,
        cboptiondata: u32,
        lpboptiondata: *mut u8,
        lpmapisup: windows_core::Ref<'_, IMAPISupport>,
        lpdatasource: windows_core::Ref<'_, IMAPIProp>,
        lppwrappedsource: windows_core::OutRef<'_, IMAPIProp>,
        lppmapierror: *mut *mut MAPIERROR,
    ) -> i32,
>;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct OPTIONDATA {
    pub ulFlags: u32,
    pub lpRecipGUID: *mut windows_core::GUID,
    pub lpszAdrType: *mut i8,
    pub lpszDLLName: *mut i8,
    pub ulOrdinal: u32,
    pub cbOptionsData: u32,
    pub lpbOptionsData: *mut u8,
    pub cOptionsProps: u32,
    pub lpOptionsProps: *mut SPropValue,
}
impl Default for OPTIONDATA {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const OPTION_TYPE_MESSAGE: u32 = 2u32;
pub const OPTION_TYPE_RECIPIENT: u32 = 1u32;
pub const OP_BOUNCE: ACTTYPE = ACTTYPE(6i32);
pub const OP_COPY: ACTTYPE = ACTTYPE(2i32);
pub const OP_DEFER_ACTION: ACTTYPE = ACTTYPE(5i32);
pub const OP_DELEGATE: ACTTYPE = ACTTYPE(8i32);
pub const OP_DELETE: ACTTYPE = ACTTYPE(10i32);
pub const OP_FORWARD: ACTTYPE = ACTTYPE(7i32);
pub const OP_MARK_AS_READ: ACTTYPE = ACTTYPE(11i32);
pub const OP_MOVE: ACTTYPE = ACTTYPE(1i32);
pub const OP_OOF_REPLY: ACTTYPE = ACTTYPE(4i32);
pub const OP_REPLY: ACTTYPE = ACTTYPE(3i32);
pub const OP_TAG: ACTTYPE = ACTTYPE(9i32);
pub const OSTF_BEST_ENCRYPTION: u32 = 536870912u32;
pub const OSTF_COMPRESSABLE_ENCRYPTION: u32 = 1073741824u32;
pub const OSTF_NO_ENCRYPTION: u32 = 2147483648u32;
pub const PDF_ENCODED: u32 = 1u32;
pub const PDF_NAMEINDATA: u32 = 2u32;
pub const PDF_NOCOMMENTS: u32 = 8u32;
pub const PDF_SAVENOENCODE: u32 = 16u32;
pub const PDF_VECTOR: u32 = 32u32;
pub const PDK1_SPI_VERSION: i32 = 65536i32;
pub const PDK2_SPI_VERSION: i32 = 65544i32;
pub const PDK3_SPI_VERSION: i32 = 65552i32;
pub type PFNIDLE =
    Option<unsafe extern "system" fn(param0: *mut core::ffi::c_void) -> windows_core::BOOL>;
pub const PID_ATT_ACCOUNT: MIMEPROPID = MIMEPROPID(63i32);
pub const PID_ATT_AUTOINLINED: MIMEPROPID = MIMEPROPID(72i32);
pub const PID_ATT_COMBINED: MIMEPROPID = MIMEPROPID(71i32);
pub const PID_ATT_FILENAME: MIMEPROPID = MIMEPROPID(45i32);
pub const PID_ATT_FORWARDTO: MIMEPROPID = MIMEPROPID(67i32);
pub const PID_ATT_GENFNAME: MIMEPROPID = MIMEPROPID(46i32);
pub const PID_ATT_GHOSTED: MIMEPROPID = MIMEPROPID(69i32);
pub const PID_ATT_ILLEGAL: MIMEPROPID = MIMEPROPID(50i32);
pub const PID_ATT_NORMSUBJ: MIMEPROPID = MIMEPROPID(49i32);
pub const PID_ATT_PRIORITY: MIMEPROPID = MIMEPROPID(54i32);
pub const PID_ATT_PRITYPE: MIMEPROPID = MIMEPROPID(47i32);
pub const PID_ATT_RECVTIME: MIMEPROPID = MIMEPROPID(53i32);
pub const PID_ATT_RENDERED: MIMEPROPID = MIMEPROPID(51i32);
pub const PID_ATT_SENTTIME: MIMEPROPID = MIMEPROPID(52i32);
pub const PID_ATT_SERVER: MIMEPROPID = MIMEPROPID(62i32);
pub const PID_ATT_STOREFOLDERID: MIMEPROPID = MIMEPROPID(68i32);
pub const PID_ATT_STOREMSGID: MIMEPROPID = MIMEPROPID(65i32);
pub const PID_ATT_SUBTYPE: MIMEPROPID = MIMEPROPID(48i32);
pub const PID_ATT_UIDL: MIMEPROPID = MIMEPROPID(64i32);
pub const PID_ATT_UNCACHEDSIZE: MIMEPROPID = MIMEPROPID(70i32);
pub const PID_ATT_USERNAME: MIMEPROPID = MIMEPROPID(66i32);
pub const PID_BASE: u32 = 2u32;
pub const PID_HDR_APPARTO: MIMEPROPID = MIMEPROPID(11i32);
pub const PID_HDR_APPROVED: MIMEPROPID = MIMEPROPID(34i32);
pub const PID_HDR_ARTICLEID: MIMEPROPID = MIMEPROPID(60i32);
pub const PID_HDR_BCC: MIMEPROPID = MIMEPROPID(16i32);
pub const PID_HDR_CC: MIMEPROPID = MIMEPROPID(29i32);
pub const PID_HDR_CNTBASE: MIMEPROPID = MIMEPROPID(23i32);
pub const PID_HDR_CNTDESC: MIMEPROPID = MIMEPROPID(21i32);
pub const PID_HDR_CNTDISP: MIMEPROPID = MIMEPROPID(22i32);
pub const PID_HDR_CNTID: MIMEPROPID = MIMEPROPID(20i32);
pub const PID_HDR_CNTLOC: MIMEPROPID = MIMEPROPID(24i32);
pub const PID_HDR_CNTTYPE: MIMEPROPID = MIMEPROPID(18i32);
pub const PID_HDR_CNTXFER: MIMEPROPID = MIMEPROPID(19i32);
pub const PID_HDR_COMMENT: MIMEPROPID = MIMEPROPID(55i32);
pub const PID_HDR_CONTROL: MIMEPROPID = MIMEPROPID(30i32);
pub const PID_HDR_DATE: MIMEPROPID = MIMEPROPID(12i32);
pub const PID_HDR_DISTRIB: MIMEPROPID = MIMEPROPID(31i32);
pub const PID_HDR_ENCODING: MIMEPROPID = MIMEPROPID(56i32);
pub const PID_HDR_ENCRYPTED: MIMEPROPID = MIMEPROPID(57i32);
pub const PID_HDR_EXPIRES: MIMEPROPID = MIMEPROPID(28i32);
pub const PID_HDR_FOLLOWUPTO: MIMEPROPID = MIMEPROPID(27i32);
pub const PID_HDR_FROM: MIMEPROPID = MIMEPROPID(6i32);
pub const PID_HDR_KEYWORDS: MIMEPROPID = MIMEPROPID(32i32);
pub const PID_HDR_LINES: MIMEPROPID = MIMEPROPID(35i32);
pub const PID_HDR_MESSAGEID: MIMEPROPID = MIMEPROPID(7i32);
pub const PID_HDR_MIMEVER: MIMEPROPID = MIMEPROPID(17i32);
pub const PID_HDR_NEWSGROUP: MIMEPROPID = MIMEPROPID(2i32);
pub const PID_HDR_NEWSGROUPS: MIMEPROPID = MIMEPROPID(3i32);
pub const PID_HDR_OFFSETS: MIMEPROPID = MIMEPROPID(58i32);
pub const PID_HDR_ORG: MIMEPROPID = MIMEPROPID(37i32);
pub const PID_HDR_PATH: MIMEPROPID = MIMEPROPID(26i32);
pub const PID_HDR_RECEIVED: MIMEPROPID = MIMEPROPID(13i32);
pub const PID_HDR_REFS: MIMEPROPID = MIMEPROPID(4i32);
pub const PID_HDR_REPLYTO: MIMEPROPID = MIMEPROPID(14i32);
pub const PID_HDR_RETRCPTTO: MIMEPROPID = MIMEPROPID(10i32);
pub const PID_HDR_RETURNPATH: MIMEPROPID = MIMEPROPID(8i32);
pub const PID_HDR_RR: MIMEPROPID = MIMEPROPID(9i32);
pub const PID_HDR_SENDER: MIMEPROPID = MIMEPROPID(61i32);
pub const PID_HDR_SUBJECT: MIMEPROPID = MIMEPROPID(5i32);
pub const PID_HDR_SUMMARY: MIMEPROPID = MIMEPROPID(33i32);
pub const PID_HDR_TO: MIMEPROPID = MIMEPROPID(25i32);
pub const PID_HDR_XMAILER: MIMEPROPID = MIMEPROPID(15i32);
pub const PID_HDR_XMSPRI: MIMEPROPID = MIMEPROPID(40i32);
pub const PID_HDR_XNEWSRDR: MIMEPROPID = MIMEPROPID(38i32);
pub const PID_HDR_XPRI: MIMEPROPID = MIMEPROPID(39i32);
pub const PID_HDR_XREF: MIMEPROPID = MIMEPROPID(36i32);
pub const PID_HDR_XUNSENT: MIMEPROPID = MIMEPROPID(59i32);
pub const PID_LAST: MIMEPROPID = MIMEPROPID(73i32);
pub const PID_PAR_BOUNDARY: MIMEPROPID = MIMEPROPID(42i32);
pub const PID_PAR_CHARSET: MIMEPROPID = MIMEPROPID(43i32);
pub const PID_PAR_FILENAME: MIMEPROPID = MIMEPROPID(41i32);
pub const PID_PAR_NAME: MIMEPROPID = MIMEPROPID(44i32);
pub const PIM_CHARSET: PROPINFOMASK = PROPINFOMASK(1i32);
pub const PIM_ENCODINGTYPE: PROPINFOMASK = PROPINFOMASK(2i32);
pub const PIM_FLAGS: PROPINFOMASK = PROPINFOMASK(8i32);
pub const PIM_PROPID: PROPINFOMASK = PROPINFOMASK(16i32);
pub const PIM_ROWNUMBER: PROPINFOMASK = PROPINFOMASK(4i32);
pub const PIM_VALUES: PROPINFOMASK = PROPINFOMASK(32i32);
pub const PIM_VTCURRENT: PROPINFOMASK = PROPINFOMASK(128i32);
pub const PIM_VTDEFAULT: PROPINFOMASK = PROPINFOMASK(64i32);
pub const PMS_HTML: u32 = 1u32;
pub const PMS_TEXT: u32 = 2u32;
pub type PREPROCESSMESSAGE = Option<
    unsafe extern "system" fn(
        lpvsession: *mut core::ffi::c_void,
        lpmessage: windows_core::Ref<'_, IMessage>,
        lpadrbook: windows_core::Ref<'_, IAddrBook>,
        lpfolder: windows_core::Ref<'_, IMAPIFolder>,
        allocatebuffer: LPALLOCATEBUFFER,
        allocatemore: LPALLOCATEMORE,
        freebuffer: LPFREEBUFFER,
        lpcoutbound: *mut u32,
        lpppmessage: *mut *mut Option<IMessage>,
        lppreciplist: *mut *mut ADRLIST,
    ) -> windows_core::HRESULT,
>;
pub const PRIHIGHEST: u32 = 32767u32;
pub const PRILOWEST: i32 = -32768i32;
pub const PRIO_NONURGENT: u32 = 4294967295u32;
pub const PRIO_NORMAL: u32 = 0u32;
pub const PRIO_URGENT: u32 = 1u32;
pub const PRIUSER: u32 = 0u32;
pub const PRIV_DL_ALLOW_OOF: u32 = 8u32;
pub const PRIV_DL_HIDE_MEMBERS: u32 = 1u32;
pub const PRIV_DL_REPORT_TO_ORIG: u32 = 2u32;
pub const PRIV_DL_REPORT_TO_OWNER: u32 = 4u32;
pub const PRMD_PAD: u32 = 3u32;
pub const PRMD_PAD_FOR_ACTIONS: u32 = 2u32;
pub const PROCESS_XP_HEADER_CACHE: u32 = 131072u32;
pub const PROFILE_DELEGATE: u32 = 2u32;
pub const PROFILE_PRIMARY_USER: u32 = 1u32;
pub const PROFILE_PUBLIC_STORE: u32 = 3u32;
pub const PROFILE_SUBSCRIPTION: u32 = 4u32;
pub const PROFILE_VERSION: u32 = 1281u32;
pub const PROPATTR_MANDATORY: u32 = 1u32;
pub const PROPATTR_NOT_PRESENT: u32 = 8u32;
pub const PROPATTR_READABLE: u32 = 2u32;
pub const PROPATTR_WRITEABLE: u32 = 4u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct PROPINFOMASK(pub i32);
pub const PROP_ACCT_DELIVERY_FOLDER: u32 = 1638658u32;
pub const PROP_ACCT_DELIVERY_STORE: u32 = 1573122u32;
pub const PROP_ACCT_ID: u32 = 65539u32;
pub const PROP_ACCT_IS_EXCH: u32 = 1310723u32;
pub const PROP_ACCT_MINI_UID: u32 = 196611u32;
pub const PROP_ACCT_NAME: u32 = 131103u32;
pub const PROP_ACCT_PREFERENCES_UID: u32 = 2228482u32;
pub const PROP_ACCT_SEND_STAMP: u32 = 917535u32;
pub const PROP_ACCT_SENTITEMS_EID: u32 = 2097410u32;
pub const PROP_ACCT_STAMP: u32 = 851999u32;
pub const PROP_ACCT_USER_DISPLAY_NAME: u32 = 720927u32;
pub const PROP_ACCT_USER_EMAIL_ADDR: u32 = 786463u32;
pub const PROP_ID_INVALID: u32 = 65535u32;
pub const PROP_ID_NULL: u32 = 0u32;
pub const PROP_ID_SECURE_MAX: u32 = 26623u32;
pub const PROP_ID_SECURE_MIN: u32 = 26608u32;
pub const PROP_INET_PASSWORD: u32 = 16908319u32;
pub const PROP_INET_PORT: u32 = 17039363u32;
pub const PROP_INET_SERVER: u32 = 16777247u32;
pub const PROP_INET_SSL: u32 = 17104899u32;
pub const PROP_INET_USER: u32 = 16842783u32;
pub const PROP_INET_USE_SPA: u32 = 17301507u32;
pub const PROP_MAPI_EMSMDB_UID: u32 = 537460994u32;
pub const PROP_MAPI_IDENTITY_ENTRYID: u32 = 537002242u32;
pub const PROP_MAPI_TRANSPORT_FLAGS: u32 = 537919746u32;
pub const PROP_POP_LEAVE_ON_SERVER: u32 = 268435459u32;
pub const PROP_SMTP_AUTH_METHOD: u32 = 34078723u32;
pub const PROP_SMTP_PASSWORD: u32 = 33882143u32;
pub const PROP_SMTP_PORT: u32 = 33619971u32;
pub const PROP_SMTP_SECURE_CONNECTION: u32 = 34209795u32;
pub const PROP_SMTP_SERVER: u32 = 33554463u32;
pub const PROP_SMTP_SSL: u32 = 33685507u32;
pub const PROP_SMTP_USER: u32 = 33816607u32;
pub const PROP_SMTP_USE_AUTH: u32 = 33751043u32;
pub const PROP_SMTP_USE_SPA: u32 = 34013187u32;
pub const PROP_TYPE_MASK: u32 = 65535u32;
pub const PR_7BIT_DISPLAY_NAME: u32 = 973013022u32;
pub const PR_ABSTRACT: u32 = 1071251486u32;
pub const PR_ABSTRACT_A: u32 = 1071251486u32;
pub const PR_ABSTRACT_W: u32 = 1071251487u32;
pub const PR_AB_DEFAULT_DIR: u32 = 1023803650u32;
pub const PR_AB_DEFAULT_PAB: u32 = 1023869186u32;
pub const PR_AB_PROVIDERS: u32 = 1023475970u32;
pub const PR_AB_PROVIDER_ID: u32 = 907346178u32;
pub const PR_AB_SEARCH_PATH: u32 = 1023742210u32;
pub const PR_AB_SEARCH_PATH_UPDATE: u32 = 1024524546u32;
pub const PR_ACCESS: u32 = 267649027u32;
pub const PR_ACCESS_LEVEL: u32 = 267845635u32;
pub const PR_ACCOUNT: u32 = 973078558u32;
pub const PR_ACCOUNT_A: u32 = 973078558u32;
pub const PR_ACCOUNT_W: u32 = 973078559u32;
pub const PR_ACKNOWLEDGEMENT_MODE: u32 = 65539u32;
pub const PR_ACL_DATA: u32 = 1071644930u32;
pub const PR_ACL_TABLE: u32 = 1071644685u32;
pub const PR_ACTIVE_USER_ENTRYID: u32 = 1716650242u32;
pub const PR_ADDRBOOK_FOR_LOCAL_SITE_ENTRYID: u32 = 1713766658u32;
pub const PR_ADDRESS_BOOK_DISPLAY_NAME: u32 = 1072168990u32;
pub const PR_ADDRESS_BOOK_ENTRYID: u32 = 1715142914u32;
pub const PR_ADDRTYPE: u32 = 805437470u32;
pub const PR_ADDRTYPE_A: u32 = 805437470u32;
pub const PR_ADDRTYPE_W: u32 = 805437471u32;
pub const PR_ADDR_CC: u32 = 244842526u32;
pub const PR_ADDR_CC_A: u32 = 244842526u32;
pub const PR_ADDR_CC_W: u32 = 244842527u32;
pub const PR_ADDR_TO: u32 = 244776990u32;
pub const PR_ADMIN_SECURITY_DESCRIPTOR: u32 = 1025573122u32;
pub const PR_ADMIN_SECURITY_DESCRIPTOR_AS_XML: u32 = 241893406u32;
pub const PR_ADMIN_SECURITY_DESCRIPTOR_AS_XML_A: u32 = 241893406u32;
pub const PR_ADMIN_SECURITY_DESCRIPTOR_AS_XML_W: u32 = 241893407u32;
pub const PR_ALTERNATE_RECIPIENT: u32 = 973144322u32;
pub const PR_ALTERNATE_RECIPIENT_ALLOWED: u32 = 131083u32;
pub const PR_ANR: u32 = 906756126u32;
pub const PR_ANR_A: u32 = 906756126u32;
pub const PR_ANR_W: u32 = 906756127u32;
pub const PR_ANTIVIRUS_SCAN_INFO: u32 = 243793950u32;
pub const PR_ANTIVIRUS_SCAN_STATUS: u32 = 243728387u32;
pub const PR_ANTIVIRUS_VENDOR: u32 = 243597342u32;
pub const PR_ANTIVIRUS_VERSION: u32 = 243662851u32;
pub const PR_ARCHIVE_DATE: u32 = 807338048u32;
pub const PR_ARCHIVE_PERIOD: u32 = 807272451u32;
pub const PR_ARCHIVE_TAG: u32 = 806879490u32;
pub const PR_ARRIVAL_TIME: u32 = 1717502016u32;
pub const PR_ASSISTANT: u32 = 976224286u32;
pub const PR_ASSISTANT_A: u32 = 976224286u32;
pub const PR_ASSISTANT_TELEPHONE_NUMBER: u32 = 976093214u32;
pub const PR_ASSISTANT_TELEPHONE_NUMBER_A: u32 = 976093214u32;
pub const PR_ASSISTANT_TELEPHONE_NUMBER_W: u32 = 976093215u32;
pub const PR_ASSISTANT_W: u32 = 976224287u32;
pub const PR_ASSOC_CONTENT_COUNT: u32 = 907476995u32;
pub const PR_ASSOC_MESSAGE_SIZE: u32 = 1723072515u32;
pub const PR_ASSOC_MESSAGE_SIZE_EXTENDED: u32 = 1723072532u32;
pub const PR_ASSOC_MSG_W_ATTACH_COUNT: u32 = 1722679299u32;
pub const PR_ATTACHMENT_X400_PARAMETERS: u32 = 922747138u32;
pub const PR_ATTACH_ADDITIONAL_INFO: u32 = 923730178u32;
pub const PR_ATTACH_CONTENT_ID: u32 = 923926558u32;
pub const PR_ATTACH_CONTENT_ID_A: u32 = 923926558u32;
pub const PR_ATTACH_CONTENT_ID_W: u32 = 923926559u32;
pub const PR_ATTACH_DATA_BIN: u32 = 922812674u32;
pub const PR_ATTACH_DATA_OBJ: u32 = 922812429u32;
pub const PR_ATTACH_ENCODING: u32 = 922878210u32;
pub const PR_ATTACH_EXTENSION: u32 = 922943518u32;
pub const PR_ATTACH_EXTENSION_A: u32 = 922943518u32;
pub const PR_ATTACH_EXTENSION_W: u32 = 922943519u32;
pub const PR_ATTACH_FILENAME: u32 = 923009054u32;
pub const PR_ATTACH_FILENAME_A: u32 = 923009054u32;
pub const PR_ATTACH_FILENAME_W: u32 = 923009055u32;
pub const PR_ATTACH_LONG_FILENAME: u32 = 923205662u32;
pub const PR_ATTACH_LONG_FILENAME_A: u32 = 923205662u32;
pub const PR_ATTACH_LONG_FILENAME_W: u32 = 923205663u32;
pub const PR_ATTACH_LONG_PATHNAME: u32 = 923598878u32;
pub const PR_ATTACH_LONG_PATHNAME_A: u32 = 923598878u32;
pub const PR_ATTACH_LONG_PATHNAME_W: u32 = 923598879u32;
pub const PR_ATTACH_METHOD: u32 = 923074563u32;
pub const PR_ATTACH_MIME_TAG: u32 = 923664414u32;
pub const PR_ATTACH_MIME_TAG_A: u32 = 923664414u32;
pub const PR_ATTACH_MIME_TAG_W: u32 = 923664415u32;
pub const PR_ATTACH_NUM: u32 = 237043715u32;
pub const PR_ATTACH_ON_ASSOC_MSG_COUNT: u32 = 1722941443u32;
pub const PR_ATTACH_ON_NORMAL_MSG_COUNT: u32 = 1722875907u32;
pub const PR_ATTACH_PATHNAME: u32 = 923271198u32;
pub const PR_ATTACH_PATHNAME_A: u32 = 923271198u32;
pub const PR_ATTACH_PATHNAME_W: u32 = 923271199u32;
pub const PR_ATTACH_RENDERING: u32 = 923336962u32;
pub const PR_ATTACH_SIZE: u32 = 236978179u32;
pub const PR_ATTACH_TAG: u32 = 923402498u32;
pub const PR_ATTACH_TRANSPORT_NAME: u32 = 923533342u32;
pub const PR_ATTACH_TRANSPORT_NAME_A: u32 = 923533342u32;
pub const PR_ATTACH_TRANSPORT_NAME_W: u32 = 923533343u32;
pub const PR_ATTR_HIDDEN: u32 = 284426251u32;
pub const PR_ATTR_READONLY: u32 = 284557323u32;
pub const PR_ATTR_SYSTEM: u32 = 284491787u32;
pub const PR_AUTHORIZING_USERS: u32 = 196866u32;
pub const PR_AUTO_ADD_NEW_SUBS: u32 = 1709506571u32;
pub const PR_AUTO_FORWARDED: u32 = 327691u32;
pub const PR_AUTO_FORWARD_COMMENT: u32 = 262174u32;
pub const PR_AUTO_FORWARD_COMMENT_A: u32 = 262174u32;
pub const PR_AUTO_FORWARD_COMMENT_W: u32 = 262175u32;
pub const PR_AUTO_RESET: u32 = 1728843848u32;
pub const PR_AUTO_RESPONSE_SUPPRESS: u32 = 1071579139u32;
pub const PR_BEEPER_TELEPHONE_NUMBER: u32 = 975241246u32;
pub const PR_BEEPER_TELEPHONE_NUMBER_A: u32 = 975241246u32;
pub const PR_BEEPER_TELEPHONE_NUMBER_W: u32 = 975241247u32;
pub const PR_BILATERAL_INFO: u32 = 1071382786u32;
pub const PR_BIRTHDAY: u32 = 977403968u32;
pub const PR_BLOCK_STATUS: u32 = 278265859u32;
pub const PR_BODY: u32 = 268435486u32;
pub const PR_BODY_A: u32 = 268435486u32;
pub const PR_BODY_CRC: u32 = 236716035u32;
pub const PR_BODY_W: u32 = 268435487u32;
pub const PR_BUSINESS2_TELEPHONE_NUMBER: u32 = 974848030u32;
pub const PR_BUSINESS2_TELEPHONE_NUMBER_A: u32 = 974848030u32;
pub const PR_BUSINESS2_TELEPHONE_NUMBER_W: u32 = 974848031u32;
pub const PR_BUSINESS_ADDRESS_CITY: u32 = 975634462u32;
pub const PR_BUSINESS_ADDRESS_CITY_A: u32 = 975634462u32;
pub const PR_BUSINESS_ADDRESS_CITY_W: u32 = 975634463u32;
pub const PR_BUSINESS_ADDRESS_COUNTRY: u32 = 975568926u32;
pub const PR_BUSINESS_ADDRESS_COUNTRY_A: u32 = 975568926u32;
pub const PR_BUSINESS_ADDRESS_COUNTRY_W: u32 = 975568927u32;
pub const PR_BUSINESS_ADDRESS_POSTAL_CODE: u32 = 975831070u32;
pub const PR_BUSINESS_ADDRESS_POSTAL_CODE_A: u32 = 975831070u32;
pub const PR_BUSINESS_ADDRESS_POSTAL_CODE_W: u32 = 975831071u32;
pub const PR_BUSINESS_ADDRESS_POST_OFFICE_BOX: u32 = 975896606u32;
pub const PR_BUSINESS_ADDRESS_POST_OFFICE_BOX_A: u32 = 975896606u32;
pub const PR_BUSINESS_ADDRESS_POST_OFFICE_BOX_W: u32 = 975896607u32;
pub const PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE: u32 = 975699998u32;
pub const PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE_A: u32 = 975699998u32;
pub const PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE_W: u32 = 975699999u32;
pub const PR_BUSINESS_ADDRESS_STREET: u32 = 975765534u32;
pub const PR_BUSINESS_ADDRESS_STREET_A: u32 = 975765534u32;
pub const PR_BUSINESS_ADDRESS_STREET_W: u32 = 975765535u32;
pub const PR_BUSINESS_FAX_NUMBER: u32 = 975437854u32;
pub const PR_BUSINESS_FAX_NUMBER_A: u32 = 975437854u32;
pub const PR_BUSINESS_FAX_NUMBER_W: u32 = 975437855u32;
pub const PR_BUSINESS_HOME_PAGE: u32 = 978386974u32;
pub const PR_BUSINESS_HOME_PAGE_A: u32 = 978386974u32;
pub const PR_BUSINESS_HOME_PAGE_W: u32 = 978386975u32;
pub const PR_BUSINESS_TELEPHONE_NUMBER: u32 = 973602846u32;
pub const PR_BUSINESS_TELEPHONE_NUMBER_A: u32 = 973602846u32;
pub const PR_BUSINESS_TELEPHONE_NUMBER_W: u32 = 973602847u32;
pub const PR_CACHED_COLUMN_COUNT: u32 = 1722548227u32;
pub const PR_CALLBACK_TELEPHONE_NUMBER: u32 = 973209630u32;
pub const PR_CALLBACK_TELEPHONE_NUMBER_A: u32 = 973209630u32;
pub const PR_CALLBACK_TELEPHONE_NUMBER_W: u32 = 973209631u32;
pub const PR_CAR_TELEPHONE_NUMBER: u32 = 975044638u32;
pub const PR_CAR_TELEPHONE_NUMBER_A: u32 = 975044638u32;
pub const PR_CAR_TELEPHONE_NUMBER_W: u32 = 975044639u32;
pub const PR_CATALOG: u32 = 240845058u32;
pub const PR_CATEG_COUNT: u32 = 1722482691u32;
pub const PR_CELLULAR_TELEPHONE_NUMBER: u32 = 974913566u32;
pub const PR_CELLULAR_TELEPHONE_NUMBER_A: u32 = 974913566u32;
pub const PR_CELLULAR_TELEPHONE_NUMBER_W: u32 = 974913567u32;
pub const PR_CHANGE_ADVISOR: u32 = 1714683917u32;
pub const PR_CHANGE_KEY: u32 = 1709310210u32;
pub const PR_CHANGE_NOTIFICATION_GUID: u32 = 1714880584u32;
pub const PR_CHILDRENS_NAMES: u32 = 978849822u32;
pub const PR_CHILDRENS_NAMES_A: u32 = 978849822u32;
pub const PR_CHILDRENS_NAMES_W: u32 = 978849823u32;
pub const PR_CI_NOTIFICATION_ENABLED: u32 = 240975883u32;
pub const PR_CI_SEARCH_ENABLED: u32 = 240910347u32;
pub const PR_CLIENT_ACTIONS: u32 = 1715798274u32;
pub const PR_CLIENT_SUBMIT_TIME: u32 = 3735616u32;
pub const PR_CODE_PAGE_ID: u32 = 1724055555u32;
pub const PR_COLLECTOR: u32 = 1714290701u32;
pub const PR_COMMENT: u32 = 805568542u32;
pub const PR_COMMENT_A: u32 = 805568542u32;
pub const PR_COMMENT_W: u32 = 805568543u32;
pub const PR_COMMON_VIEWS_ENTRYID: u32 = 904265986u32;
pub const PR_COMPANY_MAIN_PHONE_NUMBER: u32 = 978780190u32;
pub const PR_COMPANY_MAIN_PHONE_NUMBER_A: u32 = 978780190u32;
pub const PR_COMPANY_MAIN_PHONE_NUMBER_W: u32 = 978780191u32;
pub const PR_COMPANY_NAME: u32 = 974520350u32;
pub const PR_COMPANY_NAME_A: u32 = 974520350u32;
pub const PR_COMPANY_NAME_W: u32 = 974520351u32;
pub const PR_COMPUTER_NETWORK_NAME: u32 = 977862686u32;
pub const PR_COMPUTER_NETWORK_NAME_A: u32 = 977862686u32;
pub const PR_COMPUTER_NETWORK_NAME_W: u32 = 977862687u32;
pub const PR_CONFLICT_ENTRYID: u32 = 1072693506u32;
pub const PR_CONTACT_ADDRTYPES: u32 = 978587678u32;
pub const PR_CONTACT_ADDRTYPES_A: u32 = 978587678u32;
pub const PR_CONTACT_ADDRTYPES_W: u32 = 978587679u32;
pub const PR_CONTACT_COUNT: u32 = 1723269123u32;
pub const PR_CONTACT_DEFAULT_ADDRESS_INDEX: u32 = 978649091u32;
pub const PR_CONTACT_EMAIL_ADDRESSES: u32 = 978718750u32;
pub const PR_CONTACT_EMAIL_ADDRESSES_A: u32 = 978718750u32;
pub const PR_CONTACT_EMAIL_ADDRESSES_W: u32 = 978718751u32;
pub const PR_CONTACT_ENTRYIDS: u32 = 978522370u32;
pub const PR_CONTACT_VERSION: u32 = 978452552u32;
pub const PR_CONTAINER_CLASS: u32 = 907214878u32;
pub const PR_CONTAINER_CLASS_A: u32 = 907214878u32;
pub const PR_CONTAINER_CLASS_W: u32 = 907214879u32;
pub const PR_CONTAINER_CONTENTS: u32 = 906952717u32;
pub const PR_CONTAINER_FLAGS: u32 = 905969667u32;
pub const PR_CONTAINER_HIERARCHY: u32 = 906887181u32;
pub const PR_CONTAINER_MODIFY_VERSION: u32 = 907280404u32;
pub const PR_CONTENTS_SORT_ORDER: u32 = 906825731u32;
pub const PR_CONTENTS_SYNCHRONIZER: u32 = 1714225165u32;
pub const PR_CONTENT_CONFIDENTIALITY_ALGORITHM_ID: u32 = 393474u32;
pub const PR_CONTENT_CORRELATOR: u32 = 459010u32;
pub const PR_CONTENT_COUNT: u32 = 906100739u32;
pub const PR_CONTENT_IDENTIFIER: u32 = 524318u32;
pub const PR_CONTENT_IDENTIFIER_A: u32 = 524318u32;
pub const PR_CONTENT_IDENTIFIER_W: u32 = 524319u32;
pub const PR_CONTENT_INTEGRITY_CHECK: u32 = 201326850u32;
pub const PR_CONTENT_LENGTH: u32 = 589827u32;
pub const PR_CONTENT_RETURN_REQUESTED: u32 = 655371u32;
pub const PR_CONTENT_SEARCH_KEY: u32 = 1717960962u32;
pub const PR_CONTENT_UNREAD: u32 = 906166275u32;
pub const PR_CONTROL_FLAGS: u32 = 1056964611u32;
pub const PR_CONTROL_ID: u32 = 1057423618u32;
pub const PR_CONTROL_STRUCTURE: u32 = 1057030402u32;
pub const PR_CONTROL_TYPE: u32 = 1057095683u32;
pub const PR_CONVERSATION_ID: u32 = 806551810u32;
pub const PR_CONVERSATION_INDEX: u32 = 7405826u32;
pub const PR_CONVERSATION_KEY: u32 = 721154u32;
pub const PR_CONVERSATION_TOPIC: u32 = 7340062u32;
pub const PR_CONVERSATION_TOPIC_A: u32 = 7340062u32;
pub const PR_CONVERSATION_TOPIC_W: u32 = 7340063u32;
pub const PR_CONVERSION_EITS: u32 = 786690u32;
pub const PR_CONVERSION_PROHIBITED: u32 = 973275147u32;
pub const PR_CONVERSION_WITH_LOSS_PROHIBITED: u32 = 851979u32;
pub const PR_CONVERTED_EITS: u32 = 917762u32;
pub const PR_CORRELATE: u32 = 235667467u32;
pub const PR_CORRELATE_MTSID: u32 = 235733250u32;
pub const PR_COUNTRY: u32 = 975568926u32;
pub const PR_COUNTRY_A: u32 = 975568926u32;
pub const PR_COUNTRY_W: u32 = 975568927u32;
pub const PR_CREATE_TEMPLATES: u32 = 906231821u32;
pub const PR_CREATION_TIME: u32 = 805765184u32;
pub const PR_CREATION_VERSION: u32 = 236519444u32;
pub const PR_CREATOR_ENTRYID: u32 = 1073283330u32;
pub const PR_CREATOR_NAME: u32 = 1073217566u32;
pub const PR_CREATOR_SID: u32 = 240648450u32;
pub const PR_CREATOR_SID_AS_XML: u32 = 241958942u32;
pub const PR_CURRENT_VERSION: u32 = 234881044u32;
pub const PR_CUSTOMER_ID: u32 = 977928222u32;
pub const PR_CUSTOMER_ID_A: u32 = 977928222u32;
pub const PR_CUSTOMER_ID_W: u32 = 977928223u32;
pub const PR_DAM_BACK_PATCHED: u32 = 1715929099u32;
pub const PR_DAM_ORIGINAL_ENTRYID: u32 = 1715863810u32;
pub const PR_DAV_TRANSFER_SECURITY_DESCRIPTOR: u32 = 243532034u32;
pub const PR_DEFAULT_PROFILE: u32 = 1023672331u32;
pub const PR_DEFAULT_STORE: u32 = 872415243u32;
pub const PR_DEFAULT_VIEW_ENTRYID: u32 = 907411714u32;
pub const PR_DEFERRED_DELIVERY_TIME: u32 = 983104u32;
pub const PR_DEFERRED_SEND_NUMBER: u32 = 1072365571u32;
pub const PR_DEFERRED_SEND_TIME: u32 = 1072627776u32;
pub const PR_DEFERRED_SEND_UNITS: u32 = 1072431107u32;
pub const PR_DEF_CREATE_DL: u32 = 907084034u32;
pub const PR_DEF_CREATE_MAILUSER: u32 = 907149570u32;
pub const PR_DELEGATED_BY_RULE: u32 = 1071841291u32;
pub const PR_DELEGATION: u32 = 8257794u32;
pub const PR_DELETED_ASSOC_MESSAGE_SIZE_EXTENDED: u32 = 1721565204u32;
pub const PR_DELETED_ASSOC_MSG_COUNT: u32 = 1715666947u32;
pub const PR_DELETED_COUNT_TOTAL: u32 = 1728774147u32;
pub const PR_DELETED_FOLDER_COUNT: u32 = 1715535875u32;
pub const PR_DELETED_MESSAGE_SIZE_EXTENDED: u32 = 1721434132u32;
pub const PR_DELETED_MSG_COUNT: u32 = 1715470339u32;
pub const PR_DELETED_NORMAL_MESSAGE_SIZE_EXTENDED: u32 = 1721499668u32;
pub const PR_DELETED_ON: u32 = 1720647744u32;
pub const PR_DELETE_AFTER_SUBMIT: u32 = 234946571u32;
pub const PR_DELIVERY_POINT: u32 = 201785347u32;
pub const PR_DELIVER_TIME: u32 = 1048640u32;
pub const PR_DELTAX: u32 = 1057161219u32;
pub const PR_DELTAY: u32 = 1057226755u32;
pub const PR_DEPARTMENT_NAME: u32 = 974651422u32;
pub const PR_DEPARTMENT_NAME_A: u32 = 974651422u32;
pub const PR_DEPARTMENT_NAME_W: u32 = 974651423u32;
pub const PR_DEPTH: u32 = 805634051u32;
pub const PR_DESIGN_IN_PROGRESS: u32 = 1071906827u32;
pub const PR_DETAILS_TABLE: u32 = 906297357u32;
pub const PR_DISABLE_FULL_FIDELITY: u32 = 284295179u32;
pub const PR_DISABLE_PERUSER_READ: u32 = 1724186635u32;
pub const PR_DISABLE_WINSOCK: u32 = 1712848899u32;
pub const PR_DISCARD_REASON: u32 = 1114115u32;
pub const PR_DISCLOSE_RECIPIENTS: u32 = 973340683u32;
pub const PR_DISCLOSURE_OF_RECIPIENTS: u32 = 1179659u32;
pub const PR_DISCRETE_VALUES: u32 = 235798539u32;
pub const PR_DISC_VAL: u32 = 4849675u32;
pub const PR_DISPLAY_BCC: u32 = 235012126u32;
pub const PR_DISPLAY_BCC_A: u32 = 235012126u32;
pub const PR_DISPLAY_BCC_W: u32 = 235012127u32;
pub const PR_DISPLAY_CC: u32 = 235077662u32;
pub const PR_DISPLAY_CC_A: u32 = 235077662u32;
pub const PR_DISPLAY_CC_W: u32 = 235077663u32;
pub const PR_DISPLAY_NAME: u32 = 805371934u32;
pub const PR_DISPLAY_NAME_A: u32 = 805371934u32;
pub const PR_DISPLAY_NAME_PREFIX: u32 = 977600542u32;
pub const PR_DISPLAY_NAME_PREFIX_A: u32 = 977600542u32;
pub const PR_DISPLAY_NAME_PREFIX_W: u32 = 977600543u32;
pub const PR_DISPLAY_NAME_W: u32 = 805371935u32;
pub const PR_DISPLAY_TO: u32 = 235143198u32;
pub const PR_DISPLAY_TO_A: u32 = 235143198u32;
pub const PR_DISPLAY_TO_W: u32 = 235143199u32;
pub const PR_DISPLAY_TYPE: u32 = 956301315u32;
pub const PR_DISPLAY_TYPE_EX: u32 = 956628995u32;
pub const PR_DL_EXPANSION_HISTORY: u32 = 1245442u32;
pub const PR_DL_EXPANSION_PROHIBITED: u32 = 1310731u32;
pub const PR_DL_REPORT_FLAGS: u32 = 1071316995u32;
pub const PR_EFORMS_FOR_LOCALE_ENTRYID: u32 = 1713635586u32;
pub const PR_EFORMS_LOCALE_ID: u32 = 1072234499u32;
pub const PR_EFORMS_REGISTRY_ENTRYID: u32 = 1713438978u32;
pub const PR_EMAIL_ADDRESS: u32 = 805503006u32;
pub const PR_EMAIL_ADDRESS_A: u32 = 805503006u32;
pub const PR_EMAIL_ADDRESS_W: u32 = 805503007u32;
pub const PR_EMS_AB_ACCESS_CATEGORY: u32 = 2151940099u32;
pub const PR_EMS_AB_ACTIVATION_SCHEDULE: u32 = 2152005890u32;
pub const PR_EMS_AB_ACTIVATION_STYLE: u32 = 2152071171u32;
pub const PR_EMS_AB_ADC_GLOBAL_NAMES: u32 = 2356154398u32;
pub const PR_EMS_AB_ADC_GLOBAL_NAMES_A: u32 = 2356154398u32;
pub const PR_EMS_AB_ADC_GLOBAL_NAMES_W: u32 = 2356154399u32;
pub const PR_EMS_AB_ADDRESS_ENTRY_DISPLAY_TABLE: u32 = 2148991234u32;
pub const PR_EMS_AB_ADDRESS_ENTRY_DISPLAY_TABLE_MSDOS: u32 = 2152136962u32;
pub const PR_EMS_AB_ADDRESS_SYNTAX: u32 = 2149056770u32;
pub const PR_EMS_AB_ADDRESS_TYPE: u32 = 2152202270u32;
pub const PR_EMS_AB_ADDRESS_TYPE_A: u32 = 2152202270u32;
pub const PR_EMS_AB_ADDRESS_TYPE_W: u32 = 2152202271u32;
pub const PR_EMS_AB_ADMD: u32 = 2152267806u32;
pub const PR_EMS_AB_ADMD_A: u32 = 2152267806u32;
pub const PR_EMS_AB_ADMD_W: u32 = 2152267807u32;
pub const PR_EMS_AB_ADMIN_DESCRIPTION: u32 = 2152333342u32;
pub const PR_EMS_AB_ADMIN_DESCRIPTION_A: u32 = 2152333342u32;
pub const PR_EMS_AB_ADMIN_DESCRIPTION_W: u32 = 2152333343u32;
pub const PR_EMS_AB_ADMIN_DISPLAY_NAME: u32 = 2152398878u32;
pub const PR_EMS_AB_ADMIN_DISPLAY_NAME_A: u32 = 2152398878u32;
pub const PR_EMS_AB_ADMIN_DISPLAY_NAME_W: u32 = 2152398879u32;
pub const PR_EMS_AB_ADMIN_EXTENSION_DLL: u32 = 2152464414u32;
pub const PR_EMS_AB_ADMIN_EXTENSION_DLL_A: u32 = 2152464414u32;
pub const PR_EMS_AB_ADMIN_EXTENSION_DLL_W: u32 = 2152464415u32;
pub const PR_EMS_AB_ALIASED_OBJECT_NAME: u32 = 2152529950u32;
pub const PR_EMS_AB_ALIASED_OBJECT_NAME_A: u32 = 2152529950u32;
pub const PR_EMS_AB_ALIASED_OBJECT_NAME_O: u32 = 2152529933u32;
pub const PR_EMS_AB_ALIASED_OBJECT_NAME_T: u32 = 2152529950u32;
pub const PR_EMS_AB_ALIASED_OBJECT_NAME_W: u32 = 2152529951u32;
pub const PR_EMS_AB_ALT_RECIPIENT: u32 = 2152595486u32;
pub const PR_EMS_AB_ALT_RECIPIENT_A: u32 = 2152595486u32;
pub const PR_EMS_AB_ALT_RECIPIENT_BL: u32 = 2152665118u32;
pub const PR_EMS_AB_ALT_RECIPIENT_BL_A: u32 = 2152665118u32;
pub const PR_EMS_AB_ALT_RECIPIENT_BL_O: u32 = 2152661005u32;
pub const PR_EMS_AB_ALT_RECIPIENT_BL_T: u32 = 2152665118u32;
pub const PR_EMS_AB_ALT_RECIPIENT_BL_W: u32 = 2152665119u32;
pub const PR_EMS_AB_ALT_RECIPIENT_O: u32 = 2152595469u32;
pub const PR_EMS_AB_ALT_RECIPIENT_T: u32 = 2152595486u32;
pub const PR_EMS_AB_ALT_RECIPIENT_W: u32 = 2152595487u32;
pub const PR_EMS_AB_ANCESTOR_ID: u32 = 2152726786u32;
pub const PR_EMS_AB_ANONYMOUS_ACCESS: u32 = 2173108235u32;
pub const PR_EMS_AB_ANONYMOUS_ACCOUNT: u32 = 2351300638u32;
pub const PR_EMS_AB_ANONYMOUS_ACCOUNT_A: u32 = 2351300638u32;
pub const PR_EMS_AB_ANONYMOUS_ACCOUNT_W: u32 = 2351300639u32;
pub const PR_EMS_AB_ASSOCIATION_LIFETIME: u32 = 2152857603u32;
pub const PR_EMS_AB_ASSOC_NT_ACCOUNT: u32 = 2150039810u32;
pub const PR_EMS_AB_ASSOC_PROTOCOL_CFG_NNTP: u32 = 2175074334u32;
pub const PR_EMS_AB_ASSOC_PROTOCOL_CFG_NNTP_A: u32 = 2175074334u32;
pub const PR_EMS_AB_ASSOC_PROTOCOL_CFG_NNTP_O: u32 = 2175074317u32;
pub const PR_EMS_AB_ASSOC_PROTOCOL_CFG_NNTP_T: u32 = 2175074334u32;
pub const PR_EMS_AB_ASSOC_PROTOCOL_CFG_NNTP_W: u32 = 2175074335u32;
pub const PR_EMS_AB_ASSOC_REMOTE_DXA: u32 = 2152796190u32;
pub const PR_EMS_AB_ASSOC_REMOTE_DXA_A: u32 = 2152796190u32;
pub const PR_EMS_AB_ASSOC_REMOTE_DXA_O: u32 = 2152792077u32;
pub const PR_EMS_AB_ASSOC_REMOTE_DXA_T: u32 = 2152796190u32;
pub const PR_EMS_AB_ASSOC_REMOTE_DXA_W: u32 = 2152796191u32;
pub const PR_EMS_AB_ATTRIBUTE_CERTIFICATE: u32 = 2353336578u32;
pub const PR_EMS_AB_AUTHENTICATION_TO_USE: u32 = 2174353438u32;
pub const PR_EMS_AB_AUTHENTICATION_TO_USE_A: u32 = 2174353438u32;
pub const PR_EMS_AB_AUTHENTICATION_TO_USE_W: u32 = 2174353439u32;
pub const PR_EMS_AB_AUTHORITY_REVOCATION_LIST: u32 = 2149978370u32;
pub const PR_EMS_AB_AUTHORIZED_DOMAIN: u32 = 2152988702u32;
pub const PR_EMS_AB_AUTHORIZED_DOMAIN_A: u32 = 2152988702u32;
pub const PR_EMS_AB_AUTHORIZED_DOMAIN_W: u32 = 2152988703u32;
pub const PR_EMS_AB_AUTHORIZED_PASSWORD: u32 = 2153054466u32;
pub const PR_EMS_AB_AUTHORIZED_PASSWORD_CONFIRM: u32 = 2173829378u32;
pub const PR_EMS_AB_AUTHORIZED_USER: u32 = 2153119774u32;
pub const PR_EMS_AB_AUTHORIZED_USER_A: u32 = 2153119774u32;
pub const PR_EMS_AB_AUTHORIZED_USER_W: u32 = 2153119775u32;
pub const PR_EMS_AB_AUTH_ORIG_BL: u32 = 2152927262u32;
pub const PR_EMS_AB_AUTH_ORIG_BL_A: u32 = 2152927262u32;
pub const PR_EMS_AB_AUTH_ORIG_BL_O: u32 = 2152923149u32;
pub const PR_EMS_AB_AUTH_ORIG_BL_T: u32 = 2152927262u32;
pub const PR_EMS_AB_AUTH_ORIG_BL_W: u32 = 2152927263u32;
pub const PR_EMS_AB_AUTOREPLY: u32 = 2148204555u32;
pub const PR_EMS_AB_AUTOREPLY_MESSAGE: u32 = 2148139038u32;
pub const PR_EMS_AB_AUTOREPLY_MESSAGE_A: u32 = 2148139038u32;
pub const PR_EMS_AB_AUTOREPLY_MESSAGE_W: u32 = 2148139039u32;
pub const PR_EMS_AB_AUTOREPLY_SUBJECT: u32 = 2151546910u32;
pub const PR_EMS_AB_AUTOREPLY_SUBJECT_A: u32 = 2151546910u32;
pub const PR_EMS_AB_AUTOREPLY_SUBJECT_W: u32 = 2151546911u32;
pub const PR_EMS_AB_AVAILABLE_AUTHORIZATION_PACKAGES: u32 = 2172719134u32;
pub const PR_EMS_AB_AVAILABLE_AUTHORIZATION_PACKAGES_A: u32 = 2172719134u32;
pub const PR_EMS_AB_AVAILABLE_AUTHORIZATION_PACKAGES_W: u32 = 2172719135u32;
pub const PR_EMS_AB_AVAILABLE_DISTRIBUTIONS: u32 = 2173370398u32;
pub const PR_EMS_AB_AVAILABLE_DISTRIBUTIONS_A: u32 = 2173370398u32;
pub const PR_EMS_AB_AVAILABLE_DISTRIBUTIONS_W: u32 = 2173370399u32;
pub const PR_EMS_AB_BRIDGEHEAD_SERVERS: u32 = 2171867166u32;
pub const PR_EMS_AB_BRIDGEHEAD_SERVERS_A: u32 = 2171867166u32;
pub const PR_EMS_AB_BRIDGEHEAD_SERVERS_O: u32 = 2171863053u32;
pub const PR_EMS_AB_BRIDGEHEAD_SERVERS_T: u32 = 2171867166u32;
pub const PR_EMS_AB_BRIDGEHEAD_SERVERS_W: u32 = 2171867167u32;
pub const PR_EMS_AB_BUSINESS_CATEGORY: u32 = 2153189406u32;
pub const PR_EMS_AB_BUSINESS_CATEGORY_A: u32 = 2153189406u32;
pub const PR_EMS_AB_BUSINESS_CATEGORY_W: u32 = 2153189407u32;
pub const PR_EMS_AB_BUSINESS_ROLES: u32 = 2149777666u32;
pub const PR_EMS_AB_CAN_CREATE_PF: u32 = 2153254942u32;
pub const PR_EMS_AB_CAN_CREATE_PF_A: u32 = 2153254942u32;
pub const PR_EMS_AB_CAN_CREATE_PF_BL: u32 = 2153320478u32;
pub const PR_EMS_AB_CAN_CREATE_PF_BL_A: u32 = 2153320478u32;
pub const PR_EMS_AB_CAN_CREATE_PF_BL_O: u32 = 2153316365u32;
pub const PR_EMS_AB_CAN_CREATE_PF_BL_T: u32 = 2153320478u32;
pub const PR_EMS_AB_CAN_CREATE_PF_BL_W: u32 = 2153320479u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL: u32 = 2153386014u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_A: u32 = 2153386014u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_BL: u32 = 2153451550u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_BL_A: u32 = 2153451550u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_BL_O: u32 = 2153447437u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_BL_T: u32 = 2153451550u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_BL_W: u32 = 2153451551u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_O: u32 = 2153381901u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_T: u32 = 2153386014u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_W: u32 = 2153386015u32;
pub const PR_EMS_AB_CAN_CREATE_PF_O: u32 = 2153250829u32;
pub const PR_EMS_AB_CAN_CREATE_PF_T: u32 = 2153254942u32;
pub const PR_EMS_AB_CAN_CREATE_PF_W: u32 = 2153254943u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF: u32 = 2153517086u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_A: u32 = 2153517086u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_BL: u32 = 2153582622u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_BL_A: u32 = 2153582622u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_BL_O: u32 = 2153578509u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_BL_T: u32 = 2153582622u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_BL_W: u32 = 2153582623u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL: u32 = 2153648158u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_A: u32 = 2153648158u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_BL: u32 = 2153713694u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_BL_A: u32 = 2153713694u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_BL_O: u32 = 2153709581u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_BL_T: u32 = 2153713694u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_BL_W: u32 = 2153713695u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_O: u32 = 2153644045u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_T: u32 = 2153648158u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_W: u32 = 2153648159u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_O: u32 = 2153512973u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_T: u32 = 2153517086u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_W: u32 = 2153517087u32;
pub const PR_EMS_AB_CAN_PRESERVE_DNS: u32 = 2153775115u32;
pub const PR_EMS_AB_CA_CERTIFICATE: u32 = 2147684610u32;
pub const PR_EMS_AB_CERTIFICATE_CHAIN_V3: u32 = 2351366402u32;
pub const PR_EMS_AB_CERTIFICATE_REVOCATION_LIST: u32 = 2148925698u32;
pub const PR_EMS_AB_CERTIFICATE_REVOCATION_LIST_V1: u32 = 2351497474u32;
pub const PR_EMS_AB_CERTIFICATE_REVOCATION_LIST_V3: u32 = 2351431938u32;
pub const PR_EMS_AB_CHARACTER_SET: u32 = 2172977182u32;
pub const PR_EMS_AB_CHARACTER_SET_A: u32 = 2172977182u32;
pub const PR_EMS_AB_CHARACTER_SET_LIST: u32 = 2172784670u32;
pub const PR_EMS_AB_CHARACTER_SET_LIST_A: u32 = 2172784670u32;
pub const PR_EMS_AB_CHARACTER_SET_LIST_W: u32 = 2172784671u32;
pub const PR_EMS_AB_CHARACTER_SET_W: u32 = 2172977183u32;
pub const PR_EMS_AB_CHILD_RDNS: u32 = 4294447134u32;
pub const PR_EMS_AB_CLIENT_ACCESS_ENABLED: u32 = 2351169547u32;
pub const PR_EMS_AB_CLOCK_ALERT_OFFSET: u32 = 2153840643u32;
pub const PR_EMS_AB_CLOCK_ALERT_REPAIR: u32 = 2153906187u32;
pub const PR_EMS_AB_CLOCK_WARNING_OFFSET: u32 = 2153971715u32;
pub const PR_EMS_AB_CLOCK_WARNING_REPAIR: u32 = 2154037259u32;
pub const PR_EMS_AB_COMPROMISED_KEY_LIST: u32 = 2177106178u32;
pub const PR_EMS_AB_COMPUTER_NAME: u32 = 2154102814u32;
pub const PR_EMS_AB_COMPUTER_NAME_A: u32 = 2154102814u32;
pub const PR_EMS_AB_COMPUTER_NAME_W: u32 = 2154102815u32;
pub const PR_EMS_AB_CONNECTED_DOMAINS: u32 = 2154172446u32;
pub const PR_EMS_AB_CONNECTED_DOMAINS_A: u32 = 2154172446u32;
pub const PR_EMS_AB_CONNECTED_DOMAINS_W: u32 = 2154172447u32;
pub const PR_EMS_AB_CONNECTION_LIST_FILTER: u32 = 2172649730u32;
pub const PR_EMS_AB_CONNECTION_LIST_FILTER_TYPE: u32 = 2176057347u32;
pub const PR_EMS_AB_CONNECTION_TYPE: u32 = 2175991819u32;
pub const PR_EMS_AB_CONTAINERID: u32 = 4294770691u32;
pub const PR_EMS_AB_CONTAINER_INFO: u32 = 2154233859u32;
pub const PR_EMS_AB_CONTENT_TYPE: u32 = 2173042691u32;
pub const PR_EMS_AB_CONTROL_MSG_FOLDER_ID: u32 = 2173174018u32;
pub const PR_EMS_AB_CONTROL_MSG_RULES: u32 = 2173305090u32;
pub const PR_EMS_AB_COST: u32 = 2154299395u32;
pub const PR_EMS_AB_COUNTRY_NAME: u32 = 2154364958u32;
pub const PR_EMS_AB_COUNTRY_NAME_A: u32 = 2154364958u32;
pub const PR_EMS_AB_COUNTRY_NAME_W: u32 = 2154364959u32;
pub const PR_EMS_AB_CROSS_CERTIFICATE_CRL: u32 = 2351960322u32;
pub const PR_EMS_AB_CROSS_CERTIFICATE_PAIR: u32 = 2149912834u32;
pub const PR_EMS_AB_DEFAULT_MESSAGE_FORMAT: u32 = 2352414731u32;
pub const PR_EMS_AB_DELEGATE_USER: u32 = 2353594379u32;
pub const PR_EMS_AB_DELIVERY_MECHANISM: u32 = 2154692611u32;
pub const PR_EMS_AB_DELIVER_AND_REDIRECT: u32 = 2154627083u32;
pub const PR_EMS_AB_DELIV_CONT_LENGTH: u32 = 2154430467u32;
pub const PR_EMS_AB_DELIV_EITS: u32 = 2154500354u32;
pub const PR_EMS_AB_DELIV_EXT_CONT_TYPES: u32 = 2154565890u32;
pub const PR_EMS_AB_DELTA_REVOCATION_LIST: u32 = 2353402114u32;
pub const PR_EMS_AB_DESCRIPTION: u32 = 2154762270u32;
pub const PR_EMS_AB_DESCRIPTION_A: u32 = 2154762270u32;
pub const PR_EMS_AB_DESCRIPTION_W: u32 = 2154762271u32;
pub const PR_EMS_AB_DESTINATION_INDICATOR: u32 = 2154827806u32;
pub const PR_EMS_AB_DESTINATION_INDICATOR_A: u32 = 2154827806u32;
pub const PR_EMS_AB_DESTINATION_INDICATOR_W: u32 = 2154827807u32;
pub const PR_EMS_AB_DIAGNOSTIC_REG_KEY: u32 = 2154889246u32;
pub const PR_EMS_AB_DIAGNOSTIC_REG_KEY_A: u32 = 2154889246u32;
pub const PR_EMS_AB_DIAGNOSTIC_REG_KEY_W: u32 = 2154889247u32;
pub const PR_EMS_AB_DISABLED_GATEWAY_PROXY: u32 = 2177044510u32;
pub const PR_EMS_AB_DISABLED_GATEWAY_PROXY_A: u32 = 2177044510u32;
pub const PR_EMS_AB_DISABLED_GATEWAY_PROXY_W: u32 = 2177044511u32;
pub const PR_EMS_AB_DISABLE_DEFERRED_COMMIT: u32 = 2351104011u32;
pub const PR_EMS_AB_DISPLAY_NAME_OVERRIDE: u32 = 2147549195u32;
pub const PR_EMS_AB_DISPLAY_NAME_PRINTABLE: u32 = 973013022u32;
pub const PR_EMS_AB_DISPLAY_NAME_PRINTABLE_A: u32 = 973013022u32;
pub const PR_EMS_AB_DISPLAY_NAME_PRINTABLE_W: u32 = 973013023u32;
pub const PR_EMS_AB_DISPLAY_NAME_SUFFIX: u32 = 2353266718u32;
pub const PR_EMS_AB_DISPLAY_NAME_SUFFIX_A: u32 = 2353266718u32;
pub const PR_EMS_AB_DISPLAY_NAME_SUFFIX_W: u32 = 2353266719u32;
pub const PR_EMS_AB_DL_EXTERNAL_MEMBER_COUNT: u32 = 2363686915u32;
pub const PR_EMS_AB_DL_MEMBER_RULE: u32 = 2155090178u32;
pub const PR_EMS_AB_DL_MEM_REJECT_PERMS_BL: u32 = 2154958878u32;
pub const PR_EMS_AB_DL_MEM_REJECT_PERMS_BL_A: u32 = 2154958878u32;
pub const PR_EMS_AB_DL_MEM_REJECT_PERMS_BL_O: u32 = 2154954765u32;
pub const PR_EMS_AB_DL_MEM_REJECT_PERMS_BL_T: u32 = 2154958878u32;
pub const PR_EMS_AB_DL_MEM_REJECT_PERMS_BL_W: u32 = 2154958879u32;
pub const PR_EMS_AB_DL_MEM_SUBMIT_PERMS_BL: u32 = 2155024414u32;
pub const PR_EMS_AB_DL_MEM_SUBMIT_PERMS_BL_A: u32 = 2155024414u32;
pub const PR_EMS_AB_DL_MEM_SUBMIT_PERMS_BL_O: u32 = 2155020301u32;
pub const PR_EMS_AB_DL_MEM_SUBMIT_PERMS_BL_T: u32 = 2155024414u32;
pub const PR_EMS_AB_DL_MEM_SUBMIT_PERMS_BL_W: u32 = 2155024415u32;
pub const PR_EMS_AB_DMD_NAME: u32 = 2354446366u32;
pub const PR_EMS_AB_DMD_NAME_A: u32 = 2354446366u32;
pub const PR_EMS_AB_DMD_NAME_W: u32 = 2354446367u32;
pub const PR_EMS_AB_DOMAIN_DEF_ALT_RECIP: u32 = 2155151390u32;
pub const PR_EMS_AB_DOMAIN_DEF_ALT_RECIP_A: u32 = 2155151390u32;
pub const PR_EMS_AB_DOMAIN_DEF_ALT_RECIP_O: u32 = 2155151373u32;
pub const PR_EMS_AB_DOMAIN_DEF_ALT_RECIP_T: u32 = 2155151390u32;
pub const PR_EMS_AB_DOMAIN_DEF_ALT_RECIP_W: u32 = 2155151391u32;
pub const PR_EMS_AB_DOMAIN_NAME: u32 = 2155216926u32;
pub const PR_EMS_AB_DOMAIN_NAME_A: u32 = 2155216926u32;
pub const PR_EMS_AB_DOMAIN_NAME_W: u32 = 2155216927u32;
pub const PR_EMS_AB_DO_OAB_VERSION: u32 = 2352611331u32;
pub const PR_EMS_AB_DSA_SIGNATURE: u32 = 2155282690u32;
pub const PR_EMS_AB_DXA_ADMIN_COPY: u32 = 2155347979u32;
pub const PR_EMS_AB_DXA_ADMIN_FORWARD: u32 = 2155413515u32;
pub const PR_EMS_AB_DXA_ADMIN_UPDATE: u32 = 2155479043u32;
pub const PR_EMS_AB_DXA_APPEND_REQCN: u32 = 2155544587u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST: u32 = 2155614238u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_A: u32 = 2155614238u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_BL: u32 = 2356547614u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_BL_A: u32 = 2356547614u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_BL_O: u32 = 2356543501u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_BL_T: u32 = 2356547614u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_BL_W: u32 = 2356547615u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_LINKED: u32 = 2356219934u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_LINKED_A: u32 = 2356219934u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_LINKED_O: u32 = 2356215821u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_LINKED_T: u32 = 2356219934u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_LINKED_W: u32 = 2356219935u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_O: u32 = 2155610125u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_T: u32 = 2155614238u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_W: u32 = 2155614239u32;
pub const PR_EMS_AB_DXA_CONF_REQ_TIME: u32 = 2155675712u32;
pub const PR_EMS_AB_DXA_CONF_SEQ: u32 = 2155741214u32;
pub const PR_EMS_AB_DXA_CONF_SEQ_A: u32 = 2155741214u32;
pub const PR_EMS_AB_DXA_CONF_SEQ_USN: u32 = 2155806723u32;
pub const PR_EMS_AB_DXA_CONF_SEQ_W: u32 = 2155741215u32;
pub const PR_EMS_AB_DXA_EXCHANGE_OPTIONS: u32 = 2155872259u32;
pub const PR_EMS_AB_DXA_EXPORT_NOW: u32 = 2155937803u32;
pub const PR_EMS_AB_DXA_FLAGS: u32 = 2156003331u32;
pub const PR_EMS_AB_DXA_IMPORT_NOW: u32 = 2156265483u32;
pub const PR_EMS_AB_DXA_IMP_SEQ: u32 = 2156068894u32;
pub const PR_EMS_AB_DXA_IMP_SEQ_A: u32 = 2156068894u32;
pub const PR_EMS_AB_DXA_IMP_SEQ_TIME: u32 = 2156134464u32;
pub const PR_EMS_AB_DXA_IMP_SEQ_USN: u32 = 2156199939u32;
pub const PR_EMS_AB_DXA_IMP_SEQ_W: u32 = 2156068895u32;
pub const PR_EMS_AB_DXA_IN_TEMPLATE_MAP: u32 = 2156335134u32;
pub const PR_EMS_AB_DXA_IN_TEMPLATE_MAP_A: u32 = 2156335134u32;
pub const PR_EMS_AB_DXA_IN_TEMPLATE_MAP_W: u32 = 2156335135u32;
pub const PR_EMS_AB_DXA_LOCAL_ADMIN: u32 = 2156396574u32;
pub const PR_EMS_AB_DXA_LOCAL_ADMIN_A: u32 = 2156396574u32;
pub const PR_EMS_AB_DXA_LOCAL_ADMIN_O: u32 = 2156396557u32;
pub const PR_EMS_AB_DXA_LOCAL_ADMIN_T: u32 = 2156396574u32;
pub const PR_EMS_AB_DXA_LOCAL_ADMIN_W: u32 = 2156396575u32;
pub const PR_EMS_AB_DXA_LOGGING_LEVEL: u32 = 2156462083u32;
pub const PR_EMS_AB_DXA_NATIVE_ADDRESS_TYPE: u32 = 2156527646u32;
pub const PR_EMS_AB_DXA_NATIVE_ADDRESS_TYPE_A: u32 = 2156527646u32;
pub const PR_EMS_AB_DXA_NATIVE_ADDRESS_TYPE_W: u32 = 2156527647u32;
pub const PR_EMS_AB_DXA_OUT_TEMPLATE_MAP: u32 = 2156597278u32;
pub const PR_EMS_AB_DXA_OUT_TEMPLATE_MAP_A: u32 = 2156597278u32;
pub const PR_EMS_AB_DXA_OUT_TEMPLATE_MAP_W: u32 = 2156597279u32;
pub const PR_EMS_AB_DXA_PASSWORD: u32 = 2156658718u32;
pub const PR_EMS_AB_DXA_PASSWORD_A: u32 = 2156658718u32;
pub const PR_EMS_AB_DXA_PASSWORD_W: u32 = 2156658719u32;
pub const PR_EMS_AB_DXA_PREV_EXCHANGE_OPTIONS: u32 = 2156724227u32;
pub const PR_EMS_AB_DXA_PREV_EXPORT_NATIVE_ONLY: u32 = 2156789771u32;
pub const PR_EMS_AB_DXA_PREV_IN_EXCHANGE_SENSITIVITY: u32 = 2156855299u32;
pub const PR_EMS_AB_DXA_PREV_REMOTE_ENTRIES: u32 = 2156920862u32;
pub const PR_EMS_AB_DXA_PREV_REMOTE_ENTRIES_A: u32 = 2156920862u32;
pub const PR_EMS_AB_DXA_PREV_REMOTE_ENTRIES_O: u32 = 2156920845u32;
pub const PR_EMS_AB_DXA_PREV_REMOTE_ENTRIES_T: u32 = 2156920862u32;
pub const PR_EMS_AB_DXA_PREV_REMOTE_ENTRIES_W: u32 = 2156920863u32;
pub const PR_EMS_AB_DXA_PREV_REPLICATION_SENSITIVITY: u32 = 2156986371u32;
pub const PR_EMS_AB_DXA_PREV_TEMPLATE_OPTIONS: u32 = 2157051907u32;
pub const PR_EMS_AB_DXA_PREV_TYPES: u32 = 2157117443u32;
pub const PR_EMS_AB_DXA_RECIPIENT_CP: u32 = 2157183006u32;
pub const PR_EMS_AB_DXA_RECIPIENT_CP_A: u32 = 2157183006u32;
pub const PR_EMS_AB_DXA_RECIPIENT_CP_W: u32 = 2157183007u32;
pub const PR_EMS_AB_DXA_REMOTE_CLIENT: u32 = 2157248542u32;
pub const PR_EMS_AB_DXA_REMOTE_CLIENT_A: u32 = 2157248542u32;
pub const PR_EMS_AB_DXA_REMOTE_CLIENT_O: u32 = 2157248525u32;
pub const PR_EMS_AB_DXA_REMOTE_CLIENT_T: u32 = 2157248542u32;
pub const PR_EMS_AB_DXA_REMOTE_CLIENT_W: u32 = 2157248543u32;
pub const PR_EMS_AB_DXA_REQNAME: u32 = 2157510686u32;
pub const PR_EMS_AB_DXA_REQNAME_A: u32 = 2157510686u32;
pub const PR_EMS_AB_DXA_REQNAME_W: u32 = 2157510687u32;
pub const PR_EMS_AB_DXA_REQ_SEQ: u32 = 2157314078u32;
pub const PR_EMS_AB_DXA_REQ_SEQ_A: u32 = 2157314078u32;
pub const PR_EMS_AB_DXA_REQ_SEQ_TIME: u32 = 2157379648u32;
pub const PR_EMS_AB_DXA_REQ_SEQ_USN: u32 = 2157445123u32;
pub const PR_EMS_AB_DXA_REQ_SEQ_W: u32 = 2157314079u32;
pub const PR_EMS_AB_DXA_SVR_SEQ: u32 = 2157576222u32;
pub const PR_EMS_AB_DXA_SVR_SEQ_A: u32 = 2157576222u32;
pub const PR_EMS_AB_DXA_SVR_SEQ_TIME: u32 = 2157641792u32;
pub const PR_EMS_AB_DXA_SVR_SEQ_USN: u32 = 2157707267u32;
pub const PR_EMS_AB_DXA_SVR_SEQ_W: u32 = 2157576223u32;
pub const PR_EMS_AB_DXA_TASK: u32 = 2157772803u32;
pub const PR_EMS_AB_DXA_TEMPLATE_OPTIONS: u32 = 2157838339u32;
pub const PR_EMS_AB_DXA_TEMPLATE_TIMESTAMP: u32 = 2157903936u32;
pub const PR_EMS_AB_DXA_TYPES: u32 = 2157969411u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST: u32 = 2158039070u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_A: u32 = 2158039070u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_BL: u32 = 2356613150u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_BL_A: u32 = 2356613150u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_BL_O: u32 = 2356609037u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_BL_T: u32 = 2356613150u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_BL_W: u32 = 2356613151u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_LINKED: u32 = 2356285470u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_LINKED_A: u32 = 2356285470u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_LINKED_O: u32 = 2356281357u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_LINKED_T: u32 = 2356285470u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_LINKED_W: u32 = 2356285471u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_O: u32 = 2158034957u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_T: u32 = 2158039070u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_W: u32 = 2158039071u32;
pub const PR_EMS_AB_EMPLOYEE_NUMBER: u32 = 2355560478u32;
pub const PR_EMS_AB_EMPLOYEE_NUMBER_A: u32 = 2355560478u32;
pub const PR_EMS_AB_EMPLOYEE_NUMBER_W: u32 = 2355560479u32;
pub const PR_EMS_AB_EMPLOYEE_TYPE: u32 = 2355691550u32;
pub const PR_EMS_AB_EMPLOYEE_TYPE_A: u32 = 2355691550u32;
pub const PR_EMS_AB_EMPLOYEE_TYPE_W: u32 = 2355691551u32;
pub const PR_EMS_AB_ENABLED: u32 = 2350972939u32;
pub const PR_EMS_AB_ENABLED_AUTHORIZATION_PACKAGES: u32 = 2172915742u32;
pub const PR_EMS_AB_ENABLED_AUTHORIZATION_PACKAGES_A: u32 = 2172915742u32;
pub const PR_EMS_AB_ENABLED_AUTHORIZATION_PACKAGES_W: u32 = 2172915743u32;
pub const PR_EMS_AB_ENABLED_PROTOCOLS: u32 = 2172583939u32;
pub const PR_EMS_AB_ENABLED_PROTOCOL_CFG: u32 = 2175270923u32;
pub const PR_EMS_AB_ENABLE_COMPATIBILITY: u32 = 2352087051u32;
pub const PR_EMS_AB_ENCAPSULATION_METHOD: u32 = 2158100483u32;
pub const PR_EMS_AB_ENCRYPT: u32 = 2158166027u32;
pub const PR_EMS_AB_ENCRYPT_ALG_LIST_NA: u32 = 2151682078u32;
pub const PR_EMS_AB_ENCRYPT_ALG_LIST_NA_A: u32 = 2151682078u32;
pub const PR_EMS_AB_ENCRYPT_ALG_LIST_NA_W: u32 = 2151682079u32;
pub const PR_EMS_AB_ENCRYPT_ALG_LIST_OTHER: u32 = 2151747614u32;
pub const PR_EMS_AB_ENCRYPT_ALG_LIST_OTHER_A: u32 = 2151747614u32;
pub const PR_EMS_AB_ENCRYPT_ALG_LIST_OTHER_W: u32 = 2151747615u32;
pub const PR_EMS_AB_ENCRYPT_ALG_SELECTED_NA: u32 = 2151874590u32;
pub const PR_EMS_AB_ENCRYPT_ALG_SELECTED_NA_A: u32 = 2151874590u32;
pub const PR_EMS_AB_ENCRYPT_ALG_SELECTED_NA_W: u32 = 2151874591u32;
pub const PR_EMS_AB_ENCRYPT_ALG_SELECTED_OTHER: u32 = 2151481374u32;
pub const PR_EMS_AB_ENCRYPT_ALG_SELECTED_OTHER_A: u32 = 2151481374u32;
pub const PR_EMS_AB_ENCRYPT_ALG_SELECTED_OTHER_W: u32 = 2151481375u32;
pub const PR_EMS_AB_EXPAND_DLS_LOCALLY: u32 = 2158231563u32;
pub const PR_EMS_AB_EXPIRATION_TIME: u32 = 2150105152u32;
pub const PR_EMS_AB_EXPORT_CONTAINERS: u32 = 2158301214u32;
pub const PR_EMS_AB_EXPORT_CONTAINERS_A: u32 = 2158301214u32;
pub const PR_EMS_AB_EXPORT_CONTAINERS_O: u32 = 2158297101u32;
pub const PR_EMS_AB_EXPORT_CONTAINERS_T: u32 = 2158301214u32;
pub const PR_EMS_AB_EXPORT_CONTAINERS_W: u32 = 2158301215u32;
pub const PR_EMS_AB_EXPORT_CUSTOM_RECIPIENTS: u32 = 2158362635u32;
pub const PR_EMS_AB_EXTENDED_CHARS_ALLOWED: u32 = 2158428171u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_1: u32 = 2150432798u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_10: u32 = 2151022622u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_10_A: u32 = 2151022622u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_10_W: u32 = 2151022623u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_11: u32 = 2354511902u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_11_A: u32 = 2354511902u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_11_W: u32 = 2354511903u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_12: u32 = 2354577438u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_12_A: u32 = 2354577438u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_12_W: u32 = 2354577439u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_13: u32 = 2354642974u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_13_A: u32 = 2354642974u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_13_W: u32 = 2354642975u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_14: u32 = 2355101726u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_14_A: u32 = 2355101726u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_14_W: u32 = 2355101727u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_15: u32 = 2355167262u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_15_A: u32 = 2355167262u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_15_W: u32 = 2355167263u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_1_A: u32 = 2150432798u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_1_W: u32 = 2150432799u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_2: u32 = 2150498334u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_2_A: u32 = 2150498334u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_2_W: u32 = 2150498335u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_3: u32 = 2150563870u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_3_A: u32 = 2150563870u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_3_W: u32 = 2150563871u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_4: u32 = 2150629406u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_4_A: u32 = 2150629406u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_4_W: u32 = 2150629407u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_5: u32 = 2150694942u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_5_A: u32 = 2150694942u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_5_W: u32 = 2150694943u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_6: u32 = 2150760478u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_6_A: u32 = 2150760478u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_6_W: u32 = 2150760479u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_7: u32 = 2150826014u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_7_A: u32 = 2150826014u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_7_W: u32 = 2150826015u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_8: u32 = 2150891550u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_8_A: u32 = 2150891550u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_8_W: u32 = 2150891551u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_9: u32 = 2150957086u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_9_A: u32 = 2150957086u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_9_W: u32 = 2150957087u32;
pub const PR_EMS_AB_EXTENSION_DATA: u32 = 2158498050u32;
pub const PR_EMS_AB_EXTENSION_NAME: u32 = 2158563358u32;
pub const PR_EMS_AB_EXTENSION_NAME_A: u32 = 2158563358u32;
pub const PR_EMS_AB_EXTENSION_NAME_INHERITED: u32 = 2158628894u32;
pub const PR_EMS_AB_EXTENSION_NAME_INHERITED_A: u32 = 2158628894u32;
pub const PR_EMS_AB_EXTENSION_NAME_INHERITED_W: u32 = 2158628895u32;
pub const PR_EMS_AB_EXTENSION_NAME_W: u32 = 2158563359u32;
pub const PR_EMS_AB_FACSIMILE_TELEPHONE_NUMBER: u32 = 2158694658u32;
pub const PR_EMS_AB_FILE_VERSION: u32 = 2158756098u32;
pub const PR_EMS_AB_FILTER_LOCAL_ADDRESSES: u32 = 2158821387u32;
pub const PR_EMS_AB_FOLDERS_CONTAINER: u32 = 2158886942u32;
pub const PR_EMS_AB_FOLDERS_CONTAINER_A: u32 = 2158886942u32;
pub const PR_EMS_AB_FOLDERS_CONTAINER_O: u32 = 2158886925u32;
pub const PR_EMS_AB_FOLDERS_CONTAINER_T: u32 = 2158886942u32;
pub const PR_EMS_AB_FOLDERS_CONTAINER_W: u32 = 2158886943u32;
pub const PR_EMS_AB_FOLDER_PATHNAME: u32 = 2147745822u32;
pub const PR_EMS_AB_FOLDER_PATHNAME_A: u32 = 2147745822u32;
pub const PR_EMS_AB_FOLDER_PATHNAME_W: u32 = 2147745823u32;
pub const PR_EMS_AB_FORM_DATA: u32 = 2355429634u32;
pub const PR_EMS_AB_FORWARDING_ADDRESS: u32 = 2355363870u32;
pub const PR_EMS_AB_FORWARDING_ADDRESS_A: u32 = 2355363870u32;
pub const PR_EMS_AB_FORWARDING_ADDRESS_W: u32 = 2355363871u32;
pub const PR_EMS_AB_GARBAGE_COLL_PERIOD: u32 = 2158952451u32;
pub const PR_EMS_AB_GATEWAY_LOCAL_CRED: u32 = 2159018014u32;
pub const PR_EMS_AB_GATEWAY_LOCAL_CRED_A: u32 = 2159018014u32;
pub const PR_EMS_AB_GATEWAY_LOCAL_CRED_W: u32 = 2159018015u32;
pub const PR_EMS_AB_GATEWAY_LOCAL_DESIG: u32 = 2159083550u32;
pub const PR_EMS_AB_GATEWAY_LOCAL_DESIG_A: u32 = 2159083550u32;
pub const PR_EMS_AB_GATEWAY_LOCAL_DESIG_W: u32 = 2159083551u32;
pub const PR_EMS_AB_GATEWAY_PROXY: u32 = 2159153182u32;
pub const PR_EMS_AB_GATEWAY_PROXY_A: u32 = 2159153182u32;
pub const PR_EMS_AB_GATEWAY_PROXY_W: u32 = 2159153183u32;
pub const PR_EMS_AB_GATEWAY_ROUTING_TREE: u32 = 2159214850u32;
pub const PR_EMS_AB_GENERATION_QUALIFIER: u32 = 2354249758u32;
pub const PR_EMS_AB_GENERATION_QUALIFIER_A: u32 = 2354249758u32;
pub const PR_EMS_AB_GENERATION_QUALIFIER_W: u32 = 2354249759u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_1: u32 = 2176253982u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_1_A: u32 = 2176253982u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_1_W: u32 = 2176253983u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_2: u32 = 2176319518u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_2_A: u32 = 2176319518u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_2_W: u32 = 2176319519u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_3: u32 = 2176385054u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_3_A: u32 = 2176385054u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_3_W: u32 = 2176385055u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_4: u32 = 2176450590u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_4_A: u32 = 2176450590u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_4_W: u32 = 2176450591u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_DN: u32 = 2350514206u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_DN_A: u32 = 2350514206u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_DN_O: u32 = 2350514189u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_DN_T: u32 = 2350514206u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_DN_W: u32 = 2350514207u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_STR: u32 = 2350448670u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_STR_A: u32 = 2350448670u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_STR_W: u32 = 2350448671u32;
pub const PR_EMS_AB_GWART_LAST_MODIFIED: u32 = 2159280192u32;
pub const PR_EMS_AB_HAB_CHILD_DEPARTMENTS: u32 = 2358902797u32;
pub const PR_EMS_AB_HAB_DEPARTMENT_MEMBERS: u32 = 2358706189u32;
pub const PR_EMS_AB_HAB_IS_HIERARCHICAL_GROUP: u32 = 2363293707u32;
pub const PR_EMS_AB_HAB_PARENT_DEPARTMENT: u32 = 2358837261u32;
pub const PR_EMS_AB_HAB_ROOT_DEPARTMENT: u32 = 2358771725u32;
pub const PR_EMS_AB_HAB_SHOW_IN_DEPARTMENTS: u32 = 2358509581u32;
pub const PR_EMS_AB_HAS_FULL_REPLICA_NCS: u32 = 2159349790u32;
pub const PR_EMS_AB_HAS_FULL_REPLICA_NCS_A: u32 = 2159349790u32;
pub const PR_EMS_AB_HAS_FULL_REPLICA_NCS_O: u32 = 2159345677u32;
pub const PR_EMS_AB_HAS_FULL_REPLICA_NCS_T: u32 = 2159349790u32;
pub const PR_EMS_AB_HAS_FULL_REPLICA_NCS_W: u32 = 2159349791u32;
pub const PR_EMS_AB_HAS_MASTER_NCS: u32 = 2159415326u32;
pub const PR_EMS_AB_HAS_MASTER_NCS_A: u32 = 2159415326u32;
pub const PR_EMS_AB_HAS_MASTER_NCS_O: u32 = 2159411213u32;
pub const PR_EMS_AB_HAS_MASTER_NCS_T: u32 = 2159415326u32;
pub const PR_EMS_AB_HAS_MASTER_NCS_W: u32 = 2159415327u32;
pub const PR_EMS_AB_HELP_DATA16: u32 = 2151284994u32;
pub const PR_EMS_AB_HELP_DATA32: u32 = 2148532482u32;
pub const PR_EMS_AB_HELP_FILE_NAME: u32 = 2151350302u32;
pub const PR_EMS_AB_HELP_FILE_NAME_A: u32 = 2151350302u32;
pub const PR_EMS_AB_HELP_FILE_NAME_W: u32 = 2151350303u32;
pub const PR_EMS_AB_HEURISTICS: u32 = 2159476739u32;
pub const PR_EMS_AB_HIDE_DL_MEMBERSHIP: u32 = 2159542283u32;
pub const PR_EMS_AB_HIDE_FROM_ADDRESS_BOOK: u32 = 2159607819u32;
pub const PR_EMS_AB_HIERARCHY_PATH: u32 = 4294508574u32;
pub const PR_EMS_AB_HIERARCHY_PATH_A: u32 = 4294508574u32;
pub const PR_EMS_AB_HIERARCHY_PATH_W: u32 = 4294508575u32;
pub const PR_EMS_AB_HOME_MDB: u32 = 2147876894u32;
pub const PR_EMS_AB_HOME_MDB_A: u32 = 2147876894u32;
pub const PR_EMS_AB_HOME_MDB_BL: u32 = 2148798494u32;
pub const PR_EMS_AB_HOME_MDB_BL_A: u32 = 2148798494u32;
pub const PR_EMS_AB_HOME_MDB_BL_O: u32 = 2148794381u32;
pub const PR_EMS_AB_HOME_MDB_BL_T: u32 = 2148798494u32;
pub const PR_EMS_AB_HOME_MDB_BL_W: u32 = 2148798495u32;
pub const PR_EMS_AB_HOME_MDB_O: u32 = 2147876877u32;
pub const PR_EMS_AB_HOME_MDB_T: u32 = 2147876894u32;
pub const PR_EMS_AB_HOME_MDB_W: u32 = 2147876895u32;
pub const PR_EMS_AB_HOME_MTA: u32 = 2147942430u32;
pub const PR_EMS_AB_HOME_MTA_A: u32 = 2147942430u32;
pub const PR_EMS_AB_HOME_MTA_O: u32 = 2147942413u32;
pub const PR_EMS_AB_HOME_MTA_T: u32 = 2147942430u32;
pub const PR_EMS_AB_HOME_MTA_W: u32 = 2147942431u32;
pub const PR_EMS_AB_HOME_PUBLIC_SERVER: u32 = 2151612446u32;
pub const PR_EMS_AB_HOME_PUBLIC_SERVER_A: u32 = 2151612446u32;
pub const PR_EMS_AB_HOME_PUBLIC_SERVER_O: u32 = 2151612429u32;
pub const PR_EMS_AB_HOME_PUBLIC_SERVER_T: u32 = 2151612446u32;
pub const PR_EMS_AB_HOME_PUBLIC_SERVER_W: u32 = 2151612447u32;
pub const PR_EMS_AB_HOUSE_IDENTIFIER: u32 = 2354315294u32;
pub const PR_EMS_AB_HOUSE_IDENTIFIER_A: u32 = 2354315294u32;
pub const PR_EMS_AB_HOUSE_IDENTIFIER_W: u32 = 2354315295u32;
pub const PR_EMS_AB_HTTP_PUB_AB_ATTRIBUTES: u32 = 2175340574u32;
pub const PR_EMS_AB_HTTP_PUB_AB_ATTRIBUTES_A: u32 = 2175340574u32;
pub const PR_EMS_AB_HTTP_PUB_AB_ATTRIBUTES_W: u32 = 2175340575u32;
pub const PR_EMS_AB_HTTP_PUB_GAL: u32 = 2174418955u32;
pub const PR_EMS_AB_HTTP_PUB_GAL_LIMIT: u32 = 2174484483u32;
pub const PR_EMS_AB_HTTP_PUB_PF: u32 = 2174619906u32;
pub const PR_EMS_AB_HTTP_SERVERS: u32 = 2175471646u32;
pub const PR_EMS_AB_HTTP_SERVERS_A: u32 = 2175471646u32;
pub const PR_EMS_AB_HTTP_SERVERS_W: u32 = 2175471647u32;
pub const PR_EMS_AB_IMPORTED_FROM: u32 = 2151809054u32;
pub const PR_EMS_AB_IMPORTED_FROM_A: u32 = 2151809054u32;
pub const PR_EMS_AB_IMPORTED_FROM_W: u32 = 2151809055u32;
pub const PR_EMS_AB_IMPORT_CONTAINER: u32 = 2159673374u32;
pub const PR_EMS_AB_IMPORT_CONTAINER_A: u32 = 2159673374u32;
pub const PR_EMS_AB_IMPORT_CONTAINER_O: u32 = 2159673357u32;
pub const PR_EMS_AB_IMPORT_CONTAINER_T: u32 = 2159673374u32;
pub const PR_EMS_AB_IMPORT_CONTAINER_W: u32 = 2159673375u32;
pub const PR_EMS_AB_IMPORT_SENSITIVITY: u32 = 2159738883u32;
pub const PR_EMS_AB_INBOUND_ACCEPT_ALL: u32 = 2350907403u32;
pub const PR_EMS_AB_INBOUND_DN: u32 = 2350776350u32;
pub const PR_EMS_AB_INBOUND_DN_A: u32 = 2350776350u32;
pub const PR_EMS_AB_INBOUND_DN_O: u32 = 2350776333u32;
pub const PR_EMS_AB_INBOUND_DN_T: u32 = 2350776350u32;
pub const PR_EMS_AB_INBOUND_DN_W: u32 = 2350776351u32;
pub const PR_EMS_AB_INBOUND_HOST: u32 = 2173571102u32;
pub const PR_EMS_AB_INBOUND_HOST_A: u32 = 2173571102u32;
pub const PR_EMS_AB_INBOUND_HOST_W: u32 = 2173571103u32;
pub const PR_EMS_AB_INBOUND_NEWSFEED: u32 = 2173894686u32;
pub const PR_EMS_AB_INBOUND_NEWSFEED_A: u32 = 2173894686u32;
pub const PR_EMS_AB_INBOUND_NEWSFEED_TYPE: u32 = 2350841867u32;
pub const PR_EMS_AB_INBOUND_NEWSFEED_W: u32 = 2173894687u32;
pub const PR_EMS_AB_INBOUND_SITES: u32 = 2159808542u32;
pub const PR_EMS_AB_INBOUND_SITES_A: u32 = 2159808542u32;
pub const PR_EMS_AB_INBOUND_SITES_O: u32 = 2159804429u32;
pub const PR_EMS_AB_INBOUND_SITES_T: u32 = 2159808542u32;
pub const PR_EMS_AB_INBOUND_SITES_W: u32 = 2159808543u32;
pub const PR_EMS_AB_INCOMING_MSG_SIZE_LIMIT: u32 = 2173698051u32;
pub const PR_EMS_AB_INCOMING_PASSWORD: u32 = 2175729922u32;
pub const PR_EMS_AB_INSADMIN: u32 = 2177171486u32;
pub const PR_EMS_AB_INSADMIN_A: u32 = 2177171486u32;
pub const PR_EMS_AB_INSADMIN_O: u32 = 2177171469u32;
pub const PR_EMS_AB_INSADMIN_T: u32 = 2177171486u32;
pub const PR_EMS_AB_INSADMIN_W: u32 = 2177171487u32;
pub const PR_EMS_AB_INSTANCE_TYPE: u32 = 2159869955u32;
pub const PR_EMS_AB_INTERNATIONAL_ISDN_NUMBER: u32 = 2159939614u32;
pub const PR_EMS_AB_INTERNATIONAL_ISDN_NUMBER_A: u32 = 2159939614u32;
pub const PR_EMS_AB_INTERNATIONAL_ISDN_NUMBER_W: u32 = 2159939615u32;
pub const PR_EMS_AB_INVOCATION_ID: u32 = 2160001282u32;
pub const PR_EMS_AB_IS_DELETED: u32 = 2160066571u32;
pub const PR_EMS_AB_IS_MASTER: u32 = 4294639627u32;
pub const PR_EMS_AB_IS_MEMBER_OF_DL: u32 = 2148007949u32;
pub const PR_EMS_AB_IS_MEMBER_OF_DL_A: u32 = 2148012062u32;
pub const PR_EMS_AB_IS_MEMBER_OF_DL_O: u32 = 2148007949u32;
pub const PR_EMS_AB_IS_MEMBER_OF_DL_T: u32 = 2148012062u32;
pub const PR_EMS_AB_IS_MEMBER_OF_DL_W: u32 = 2148012063u32;
pub const PR_EMS_AB_IS_SINGLE_VALUED: u32 = 2160132107u32;
pub const PR_EMS_AB_KCC_STATUS: u32 = 2160201986u32;
pub const PR_EMS_AB_KM_SERVER: u32 = 2148335646u32;
pub const PR_EMS_AB_KM_SERVER_A: u32 = 2148335646u32;
pub const PR_EMS_AB_KM_SERVER_O: u32 = 2148335629u32;
pub const PR_EMS_AB_KM_SERVER_T: u32 = 2148335646u32;
pub const PR_EMS_AB_KM_SERVER_W: u32 = 2148335647u32;
pub const PR_EMS_AB_KNOWLEDGE_INFORMATION: u32 = 2160267294u32;
pub const PR_EMS_AB_KNOWLEDGE_INFORMATION_A: u32 = 2160267294u32;
pub const PR_EMS_AB_KNOWLEDGE_INFORMATION_W: u32 = 2160267295u32;
pub const PR_EMS_AB_LABELEDURI: u32 = 2354118686u32;
pub const PR_EMS_AB_LABELEDURI_A: u32 = 2354118686u32;
pub const PR_EMS_AB_LABELEDURI_W: u32 = 2354118687u32;
pub const PR_EMS_AB_LANGUAGE: u32 = 2172125187u32;
pub const PR_EMS_AB_LANGUAGE_ISO639: u32 = 2355888158u32;
pub const PR_EMS_AB_LANGUAGE_ISO639_A: u32 = 2355888158u32;
pub const PR_EMS_AB_LANGUAGE_ISO639_W: u32 = 2355888159u32;
pub const PR_EMS_AB_LDAP_DISPLAY_NAME: u32 = 2171670558u32;
pub const PR_EMS_AB_LDAP_DISPLAY_NAME_A: u32 = 2171670558u32;
pub const PR_EMS_AB_LDAP_DISPLAY_NAME_W: u32 = 2171670559u32;
pub const PR_EMS_AB_LDAP_SEARCH_CFG: u32 = 2350710787u32;
pub const PR_EMS_AB_LINE_WRAP: u32 = 2160328707u32;
pub const PR_EMS_AB_LINK_ID: u32 = 2160394243u32;
pub const PR_EMS_AB_LIST_PUBLIC_FOLDERS: u32 = 2354053131u32;
pub const PR_EMS_AB_LOCAL_BRIDGE_HEAD: u32 = 2160459806u32;
pub const PR_EMS_AB_LOCAL_BRIDGE_HEAD_A: u32 = 2160459806u32;
pub const PR_EMS_AB_LOCAL_BRIDGE_HEAD_ADDRESS: u32 = 2160525342u32;
pub const PR_EMS_AB_LOCAL_BRIDGE_HEAD_ADDRESS_A: u32 = 2160525342u32;
pub const PR_EMS_AB_LOCAL_BRIDGE_HEAD_ADDRESS_W: u32 = 2160525343u32;
pub const PR_EMS_AB_LOCAL_BRIDGE_HEAD_W: u32 = 2160459807u32;
pub const PR_EMS_AB_LOCAL_INITIAL_TURN: u32 = 2160590859u32;
pub const PR_EMS_AB_LOCAL_SCOPE: u32 = 2160660510u32;
pub const PR_EMS_AB_LOCAL_SCOPE_A: u32 = 2160660510u32;
pub const PR_EMS_AB_LOCAL_SCOPE_O: u32 = 2160656397u32;
pub const PR_EMS_AB_LOCAL_SCOPE_T: u32 = 2160660510u32;
pub const PR_EMS_AB_LOCAL_SCOPE_W: u32 = 2160660511u32;
pub const PR_EMS_AB_LOG_FILENAME: u32 = 2160721950u32;
pub const PR_EMS_AB_LOG_FILENAME_A: u32 = 2160721950u32;
pub const PR_EMS_AB_LOG_FILENAME_W: u32 = 2160721951u32;
pub const PR_EMS_AB_LOG_ROLLOVER_INTERVAL: u32 = 2160787459u32;
pub const PR_EMS_AB_MAIL_DROP: u32 = 2355298334u32;
pub const PR_EMS_AB_MAIL_DROP_A: u32 = 2355298334u32;
pub const PR_EMS_AB_MAIL_DROP_W: u32 = 2355298335u32;
pub const PR_EMS_AB_MAINTAIN_AUTOREPLY_HISTORY: u32 = 2160853003u32;
pub const PR_EMS_AB_MANAGER: u32 = 2147811341u32;
pub const PR_EMS_AB_MANAGER_A: u32 = 2147811358u32;
pub const PR_EMS_AB_MANAGER_O: u32 = 2147811341u32;
pub const PR_EMS_AB_MANAGER_T: u32 = 2147811358u32;
pub const PR_EMS_AB_MANAGER_W: u32 = 2147811359u32;
pub const PR_EMS_AB_MAPI_DISPLAY_TYPE: u32 = 2160918531u32;
pub const PR_EMS_AB_MAPI_ID: u32 = 2160984067u32;
pub const PR_EMS_AB_MAXIMUM_OBJECT_ID: u32 = 2171142402u32;
pub const PR_EMS_AB_MDB_BACKOFF_INTERVAL: u32 = 2161049603u32;
pub const PR_EMS_AB_MDB_MSG_TIME_OUT_PERIOD: u32 = 2161115139u32;
pub const PR_EMS_AB_MDB_OVER_QUOTA_LIMIT: u32 = 2161180675u32;
pub const PR_EMS_AB_MDB_STORAGE_QUOTA: u32 = 2161246211u32;
pub const PR_EMS_AB_MDB_UNREAD_LIMIT: u32 = 2161311747u32;
pub const PR_EMS_AB_MDB_USE_DEFAULTS: u32 = 2161377291u32;
pub const PR_EMS_AB_MEMBER: u32 = 2148073485u32;
pub const PR_EMS_AB_MEMBER_A: u32 = 2148077598u32;
pub const PR_EMS_AB_MEMBER_O: u32 = 2148073485u32;
pub const PR_EMS_AB_MEMBER_T: u32 = 2148077598u32;
pub const PR_EMS_AB_MEMBER_W: u32 = 2148077599u32;
pub const PR_EMS_AB_MESSAGE_TRACKING_ENABLED: u32 = 2161442827u32;
pub const PR_EMS_AB_MIME_TYPES: u32 = 2350645506u32;
pub const PR_EMS_AB_MODERATED: u32 = 2175533067u32;
pub const PR_EMS_AB_MODERATOR: u32 = 2174287902u32;
pub const PR_EMS_AB_MODERATOR_A: u32 = 2174287902u32;
pub const PR_EMS_AB_MODERATOR_W: u32 = 2174287903u32;
pub const PR_EMS_AB_MONITORED_CONFIGURATIONS: u32 = 2161709086u32;
pub const PR_EMS_AB_MONITORED_CONFIGURATIONS_A: u32 = 2161709086u32;
pub const PR_EMS_AB_MONITORED_CONFIGURATIONS_O: u32 = 2161704973u32;
pub const PR_EMS_AB_MONITORED_CONFIGURATIONS_T: u32 = 2161709086u32;
pub const PR_EMS_AB_MONITORED_CONFIGURATIONS_W: u32 = 2161709087u32;
pub const PR_EMS_AB_MONITORED_SERVERS: u32 = 2161774622u32;
pub const PR_EMS_AB_MONITORED_SERVERS_A: u32 = 2161774622u32;
pub const PR_EMS_AB_MONITORED_SERVERS_O: u32 = 2161770509u32;
pub const PR_EMS_AB_MONITORED_SERVERS_T: u32 = 2161774622u32;
pub const PR_EMS_AB_MONITORED_SERVERS_W: u32 = 2161774623u32;
pub const PR_EMS_AB_MONITORED_SERVICES: u32 = 2161840158u32;
pub const PR_EMS_AB_MONITORED_SERVICES_A: u32 = 2161840158u32;
pub const PR_EMS_AB_MONITORED_SERVICES_W: u32 = 2161840159u32;
pub const PR_EMS_AB_MONITORING_ALERT_DELAY: u32 = 2161901571u32;
pub const PR_EMS_AB_MONITORING_ALERT_UNITS: u32 = 2161967107u32;
pub const PR_EMS_AB_MONITORING_AVAILABILITY_STYLE: u32 = 2162032643u32;
pub const PR_EMS_AB_MONITORING_AVAILABILITY_WINDOW: u32 = 2162098434u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_MAIL: u32 = 2162167838u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_MAIL_A: u32 = 2162167838u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_MAIL_O: u32 = 2162163725u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_MAIL_T: u32 = 2162167838u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_MAIL_W: u32 = 2162167839u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_RPC: u32 = 2162233374u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_RPC_A: u32 = 2162233374u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_RPC_O: u32 = 2162229261u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_RPC_T: u32 = 2162233374u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_RPC_W: u32 = 2162233375u32;
pub const PR_EMS_AB_MONITORING_ESCALATION_PROCEDURE: u32 = 2162299138u32;
pub const PR_EMS_AB_MONITORING_HOTSITE_POLL_INTERVAL: u32 = 2162360323u32;
pub const PR_EMS_AB_MONITORING_HOTSITE_POLL_UNITS: u32 = 2162425859u32;
pub const PR_EMS_AB_MONITORING_MAIL_UPDATE_INTERVAL: u32 = 2162491395u32;
pub const PR_EMS_AB_MONITORING_MAIL_UPDATE_UNITS: u32 = 2162556931u32;
pub const PR_EMS_AB_MONITORING_NORMAL_POLL_INTERVAL: u32 = 2162622467u32;
pub const PR_EMS_AB_MONITORING_NORMAL_POLL_UNITS: u32 = 2162688003u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS: u32 = 2162757662u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_A: u32 = 2162757662u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_NDR: u32 = 2162823198u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_NDR_A: u32 = 2162823198u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_NDR_O: u32 = 2162819085u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_NDR_T: u32 = 2162823198u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_NDR_W: u32 = 2162823199u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_O: u32 = 2162753549u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_T: u32 = 2162757662u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_W: u32 = 2162757663u32;
pub const PR_EMS_AB_MONITORING_RPC_UPDATE_INTERVAL: u32 = 2162884611u32;
pub const PR_EMS_AB_MONITORING_RPC_UPDATE_UNITS: u32 = 2162950147u32;
pub const PR_EMS_AB_MONITORING_WARNING_DELAY: u32 = 2163015683u32;
pub const PR_EMS_AB_MONITORING_WARNING_UNITS: u32 = 2163081219u32;
pub const PR_EMS_AB_MONITOR_CLOCK: u32 = 2161508363u32;
pub const PR_EMS_AB_MONITOR_SERVERS: u32 = 2161573899u32;
pub const PR_EMS_AB_MONITOR_SERVICES: u32 = 2161639435u32;
pub const PR_EMS_AB_MTA_LOCAL_CRED: u32 = 2163146782u32;
pub const PR_EMS_AB_MTA_LOCAL_CRED_A: u32 = 2163146782u32;
pub const PR_EMS_AB_MTA_LOCAL_CRED_W: u32 = 2163146783u32;
pub const PR_EMS_AB_MTA_LOCAL_DESIG: u32 = 2163212318u32;
pub const PR_EMS_AB_MTA_LOCAL_DESIG_A: u32 = 2163212318u32;
pub const PR_EMS_AB_MTA_LOCAL_DESIG_W: u32 = 2163212319u32;
pub const PR_EMS_AB_NETWORK_ADDRESS: u32 = 2171605022u32;
pub const PR_EMS_AB_NETWORK_ADDRESS_A: u32 = 2171605022u32;
pub const PR_EMS_AB_NETWORK_ADDRESS_W: u32 = 2171605023u32;
pub const PR_EMS_AB_NEWSFEED_TYPE: u32 = 2173960195u32;
pub const PR_EMS_AB_NEWSGROUP: u32 = 2174222366u32;
pub const PR_EMS_AB_NEWSGROUP_A: u32 = 2174222366u32;
pub const PR_EMS_AB_NEWSGROUP_LIST: u32 = 2174091522u32;
pub const PR_EMS_AB_NEWSGROUP_W: u32 = 2174222367u32;
pub const PR_EMS_AB_NNTP_CHARACTER_SET: u32 = 2172452894u32;
pub const PR_EMS_AB_NNTP_CHARACTER_SET_A: u32 = 2172452894u32;
pub const PR_EMS_AB_NNTP_CHARACTER_SET_W: u32 = 2172452895u32;
pub const PR_EMS_AB_NNTP_CONTENT_FORMAT: u32 = 2171994142u32;
pub const PR_EMS_AB_NNTP_CONTENT_FORMAT_A: u32 = 2171994142u32;
pub const PR_EMS_AB_NNTP_CONTENT_FORMAT_W: u32 = 2171994143u32;
pub const PR_EMS_AB_NNTP_DISTRIBUTIONS: u32 = 2174160926u32;
pub const PR_EMS_AB_NNTP_DISTRIBUTIONS_A: u32 = 2174160926u32;
pub const PR_EMS_AB_NNTP_DISTRIBUTIONS_FLAG: u32 = 2175008779u32;
pub const PR_EMS_AB_NNTP_DISTRIBUTIONS_W: u32 = 2174160927u32;
pub const PR_EMS_AB_NNTP_NEWSFEEDS: u32 = 2175143966u32;
pub const PR_EMS_AB_NNTP_NEWSFEEDS_A: u32 = 2175143966u32;
pub const PR_EMS_AB_NNTP_NEWSFEEDS_O: u32 = 2175139853u32;
pub const PR_EMS_AB_NNTP_NEWSFEEDS_T: u32 = 2175143966u32;
pub const PR_EMS_AB_NNTP_NEWSFEEDS_W: u32 = 2175143967u32;
pub const PR_EMS_AB_NT_MACHINE_NAME: u32 = 2163408926u32;
pub const PR_EMS_AB_NT_MACHINE_NAME_A: u32 = 2163408926u32;
pub const PR_EMS_AB_NT_MACHINE_NAME_W: u32 = 2163408927u32;
pub const PR_EMS_AB_NT_SECURITY_DESCRIPTOR: u32 = 2148729090u32;
pub const PR_EMS_AB_NUM_OF_OPEN_RETRIES: u32 = 2163474435u32;
pub const PR_EMS_AB_NUM_OF_TRANSFER_RETRIES: u32 = 2163539971u32;
pub const PR_EMS_AB_N_ADDRESS: u32 = 2163278082u32;
pub const PR_EMS_AB_N_ADDRESS_TYPE: u32 = 2163343363u32;
pub const PR_EMS_AB_OBJECT_CLASS_CATEGORY: u32 = 2163605507u32;
pub const PR_EMS_AB_OBJECT_GUID: u32 = 2355953922u32;
pub const PR_EMS_AB_OBJECT_OID: u32 = 4294574338u32;
pub const PR_EMS_AB_OBJECT_VERSION: u32 = 2163671043u32;
pub const PR_EMS_AB_OBJ_DIST_NAME: u32 = 2151415838u32;
pub const PR_EMS_AB_OBJ_DIST_NAME_A: u32 = 2151415838u32;
pub const PR_EMS_AB_OBJ_DIST_NAME_O: u32 = 2151415821u32;
pub const PR_EMS_AB_OBJ_DIST_NAME_T: u32 = 2151415838u32;
pub const PR_EMS_AB_OBJ_DIST_NAME_W: u32 = 2151415839u32;
pub const PR_EMS_AB_OBJ_VIEW_CONTAINERS: u32 = 2177306654u32;
pub const PR_EMS_AB_OBJ_VIEW_CONTAINERS_A: u32 = 2177306654u32;
pub const PR_EMS_AB_OBJ_VIEW_CONTAINERS_O: u32 = 2177302541u32;
pub const PR_EMS_AB_OBJ_VIEW_CONTAINERS_T: u32 = 2177306654u32;
pub const PR_EMS_AB_OBJ_VIEW_CONTAINERS_W: u32 = 2177306655u32;
pub const PR_EMS_AB_OFF_LINE_AB_CONTAINERS: u32 = 2163740702u32;
pub const PR_EMS_AB_OFF_LINE_AB_CONTAINERS_A: u32 = 2163740702u32;
pub const PR_EMS_AB_OFF_LINE_AB_CONTAINERS_O: u32 = 2163736589u32;
pub const PR_EMS_AB_OFF_LINE_AB_CONTAINERS_T: u32 = 2163740702u32;
pub const PR_EMS_AB_OFF_LINE_AB_CONTAINERS_W: u32 = 2163740703u32;
pub const PR_EMS_AB_OFF_LINE_AB_SCHEDULE: u32 = 2163802370u32;
pub const PR_EMS_AB_OFF_LINE_AB_SERVER: u32 = 2163867678u32;
pub const PR_EMS_AB_OFF_LINE_AB_SERVER_A: u32 = 2163867678u32;
pub const PR_EMS_AB_OFF_LINE_AB_SERVER_O: u32 = 2163867661u32;
pub const PR_EMS_AB_OFF_LINE_AB_SERVER_T: u32 = 2163867678u32;
pub const PR_EMS_AB_OFF_LINE_AB_SERVER_W: u32 = 2163867679u32;
pub const PR_EMS_AB_OFF_LINE_AB_STYLE: u32 = 2163933187u32;
pub const PR_EMS_AB_OID_TYPE: u32 = 2163998723u32;
pub const PR_EMS_AB_OM_OBJECT_CLASS: u32 = 2164064514u32;
pub const PR_EMS_AB_OM_SYNTAX: u32 = 2164129795u32;
pub const PR_EMS_AB_OOF_REPLY_TO_ORIGINATOR: u32 = 2164195339u32;
pub const PR_EMS_AB_OPEN_RETRY_INTERVAL: u32 = 2164260867u32;
pub const PR_EMS_AB_ORGANIZATIONAL_UNIT_NAME: u32 = 2164396062u32;
pub const PR_EMS_AB_ORGANIZATIONAL_UNIT_NAME_A: u32 = 2164396062u32;
pub const PR_EMS_AB_ORGANIZATIONAL_UNIT_NAME_W: u32 = 2164396063u32;
pub const PR_EMS_AB_ORGANIZATION_NAME: u32 = 2164330526u32;
pub const PR_EMS_AB_ORGANIZATION_NAME_A: u32 = 2164330526u32;
pub const PR_EMS_AB_ORGANIZATION_NAME_W: u32 = 2164330527u32;
pub const PR_EMS_AB_ORG_UNIT_ROOT_DN: u32 = 2359820318u32;
pub const PR_EMS_AB_ORIGINAL_DISPLAY_TABLE: u32 = 2164457730u32;
pub const PR_EMS_AB_ORIGINAL_DISPLAY_TABLE_MSDOS: u32 = 2164523266u32;
pub const PR_EMS_AB_OTHER_RECIPS: u32 = 4026531853u32;
pub const PR_EMS_AB_OUTBOUND_HOST: u32 = 2173501698u32;
pub const PR_EMS_AB_OUTBOUND_HOST_TYPE: u32 = 2175795211u32;
pub const PR_EMS_AB_OUTBOUND_NEWSFEED: u32 = 2174025758u32;
pub const PR_EMS_AB_OUTBOUND_NEWSFEED_A: u32 = 2174025758u32;
pub const PR_EMS_AB_OUTBOUND_NEWSFEED_W: u32 = 2174025759u32;
pub const PR_EMS_AB_OUTBOUND_SITES: u32 = 2164592670u32;
pub const PR_EMS_AB_OUTBOUND_SITES_A: u32 = 2164592670u32;
pub const PR_EMS_AB_OUTBOUND_SITES_O: u32 = 2164588557u32;
pub const PR_EMS_AB_OUTBOUND_SITES_T: u32 = 2164592670u32;
pub const PR_EMS_AB_OUTBOUND_SITES_W: u32 = 2164592671u32;
pub const PR_EMS_AB_OUTGOING_MSG_SIZE_LIMIT: u32 = 2173632515u32;
pub const PR_EMS_AB_OVERRIDE_NNTP_CONTENT_FORMAT: u32 = 2177237003u32;
pub const PR_EMS_AB_OWA_SERVER: u32 = 2355494942u32;
pub const PR_EMS_AB_OWA_SERVER_A: u32 = 2355494942u32;
pub const PR_EMS_AB_OWA_SERVER_W: u32 = 2355494943u32;
pub const PR_EMS_AB_OWNER: u32 = 2148270110u32;
pub const PR_EMS_AB_OWNER_A: u32 = 2148270110u32;
pub const PR_EMS_AB_OWNER_BL: u32 = 2149847070u32;
pub const PR_EMS_AB_OWNER_BL_A: u32 = 2149847070u32;
pub const PR_EMS_AB_OWNER_BL_O: u32 = 2149842957u32;
pub const PR_EMS_AB_OWNER_BL_T: u32 = 2149847070u32;
pub const PR_EMS_AB_OWNER_BL_W: u32 = 2149847071u32;
pub const PR_EMS_AB_OWNER_O: u32 = 2148270093u32;
pub const PR_EMS_AB_OWNER_T: u32 = 2148270110u32;
pub const PR_EMS_AB_OWNER_W: u32 = 2148270111u32;
pub const PR_EMS_AB_PARENT_ENTRYID: u32 = 4294705410u32;
pub const PR_EMS_AB_PERIOD_REPL_STAGGER: u32 = 2164981763u32;
pub const PR_EMS_AB_PERIOD_REP_SYNC_TIMES: u32 = 2164916482u32;
pub const PR_EMS_AB_PERSONAL_TITLE: u32 = 2355822622u32;
pub const PR_EMS_AB_PERSONAL_TITLE_A: u32 = 2355822622u32;
pub const PR_EMS_AB_PERSONAL_TITLE_W: u32 = 2355822623u32;
pub const PR_EMS_AB_PER_MSG_DIALOG_DISPLAY_TABLE: u32 = 2164785410u32;
pub const PR_EMS_AB_PER_RECIP_DIALOG_DISPLAY_TABLE: u32 = 2164850946u32;
pub const PR_EMS_AB_PF_CONTACTS: u32 = 2151157790u32;
pub const PR_EMS_AB_PF_CONTACTS_A: u32 = 2151157790u32;
pub const PR_EMS_AB_PF_CONTACTS_O: u32 = 2151153677u32;
pub const PR_EMS_AB_PF_CONTACTS_T: u32 = 2151157790u32;
pub const PR_EMS_AB_PF_CONTACTS_W: u32 = 2151157791u32;
pub const PR_EMS_AB_PHONETIC_COMPANY_NAME: u32 = 2358312990u32;
pub const PR_EMS_AB_PHONETIC_COMPANY_NAME_A: u32 = 2358312990u32;
pub const PR_EMS_AB_PHONETIC_COMPANY_NAME_W: u32 = 2358312991u32;
pub const PR_EMS_AB_PHONETIC_DEPARTMENT_NAME: u32 = 2358247454u32;
pub const PR_EMS_AB_PHONETIC_DEPARTMENT_NAME_A: u32 = 2358247454u32;
pub const PR_EMS_AB_PHONETIC_DEPARTMENT_NAME_W: u32 = 2358247455u32;
pub const PR_EMS_AB_PHONETIC_DISPLAY_NAME: u32 = 2358378526u32;
pub const PR_EMS_AB_PHONETIC_DISPLAY_NAME_A: u32 = 2358378526u32;
pub const PR_EMS_AB_PHONETIC_DISPLAY_NAME_W: u32 = 2358378527u32;
pub const PR_EMS_AB_PHONETIC_GIVEN_NAME: u32 = 2358116382u32;
pub const PR_EMS_AB_PHONETIC_GIVEN_NAME_A: u32 = 2358116382u32;
pub const PR_EMS_AB_PHONETIC_GIVEN_NAME_W: u32 = 2358116383u32;
pub const PR_EMS_AB_PHONETIC_SURNAME: u32 = 2358181918u32;
pub const PR_EMS_AB_PHONETIC_SURNAME_A: u32 = 2358181918u32;
pub const PR_EMS_AB_PHONETIC_SURNAME_W: u32 = 2358181919u32;
pub const PR_EMS_AB_POP_CHARACTER_SET: u32 = 2172190750u32;
pub const PR_EMS_AB_POP_CHARACTER_SET_A: u32 = 2172190750u32;
pub const PR_EMS_AB_POP_CHARACTER_SET_W: u32 = 2172190751u32;
pub const PR_EMS_AB_POP_CONTENT_FORMAT: u32 = 2172059678u32;
pub const PR_EMS_AB_POP_CONTENT_FORMAT_A: u32 = 2172059678u32;
pub const PR_EMS_AB_POP_CONTENT_FORMAT_W: u32 = 2172059679u32;
pub const PR_EMS_AB_PORT_NUMBER: u32 = 2176122883u32;
pub const PR_EMS_AB_POSTAL_ADDRESS: u32 = 2165051650u32;
pub const PR_EMS_AB_PREFERRED_DELIVERY_METHOD: u32 = 2165116931u32;
pub const PR_EMS_AB_PRESERVE_INTERNET_CONTENT: u32 = 2351038475u32;
pub const PR_EMS_AB_PRMD: u32 = 2165178398u32;
pub const PR_EMS_AB_PRMD_A: u32 = 2165178398u32;
pub const PR_EMS_AB_PRMD_W: u32 = 2165178399u32;
pub const PR_EMS_AB_PROMO_EXPIRATION: u32 = 2176974912u32;
pub const PR_EMS_AB_PROTOCOL_SETTINGS: u32 = 2176192542u32;
pub const PR_EMS_AB_PROTOCOL_SETTINGS_A: u32 = 2176192542u32;
pub const PR_EMS_AB_PROTOCOL_SETTINGS_W: u32 = 2176192543u32;
pub const PR_EMS_AB_PROXY_ADDRESSES: u32 = 2148470814u32;
pub const PR_EMS_AB_PROXY_ADDRESSES_A: u32 = 2148470814u32;
pub const PR_EMS_AB_PROXY_ADDRESSES_W: u32 = 2148470815u32;
pub const PR_EMS_AB_PROXY_GENERATION_ENABLED: u32 = 2175860747u32;
pub const PR_EMS_AB_PROXY_GENERATOR_DLL: u32 = 2165243934u32;
pub const PR_EMS_AB_PROXY_GENERATOR_DLL_A: u32 = 2165243934u32;
pub const PR_EMS_AB_PROXY_GENERATOR_DLL_W: u32 = 2165243935u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES: u32 = 2148859917u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_A: u32 = 2148864030u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_BL: u32 = 2165313566u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_BL_A: u32 = 2165313566u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_BL_O: u32 = 2165309453u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_BL_T: u32 = 2165313566u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_BL_W: u32 = 2165313567u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_O: u32 = 2148859917u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_T: u32 = 2148864030u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_W: u32 = 2148864031u32;
pub const PR_EMS_AB_P_SELECTOR: u32 = 2164654338u32;
pub const PR_EMS_AB_P_SELECTOR_INBOUND: u32 = 2164719874u32;
pub const PR_EMS_AB_QUOTA_NOTIFICATION_SCHEDULE: u32 = 2165375234u32;
pub const PR_EMS_AB_QUOTA_NOTIFICATION_STYLE: u32 = 2165440515u32;
pub const PR_EMS_AB_RANGE_LOWER: u32 = 2165506051u32;
pub const PR_EMS_AB_RANGE_UPPER: u32 = 2165571587u32;
pub const PR_EMS_AB_RAS_ACCOUNT: u32 = 2175598622u32;
pub const PR_EMS_AB_RAS_ACCOUNT_A: u32 = 2175598622u32;
pub const PR_EMS_AB_RAS_ACCOUNT_W: u32 = 2175598623u32;
pub const PR_EMS_AB_RAS_CALLBACK_NUMBER: u32 = 2165637150u32;
pub const PR_EMS_AB_RAS_CALLBACK_NUMBER_A: u32 = 2165637150u32;
pub const PR_EMS_AB_RAS_CALLBACK_NUMBER_W: u32 = 2165637151u32;
pub const PR_EMS_AB_RAS_PASSWORD: u32 = 2175664386u32;
pub const PR_EMS_AB_RAS_PHONEBOOK_ENTRY_NAME: u32 = 2165768222u32;
pub const PR_EMS_AB_RAS_PHONEBOOK_ENTRY_NAME_A: u32 = 2165768222u32;
pub const PR_EMS_AB_RAS_PHONEBOOK_ENTRY_NAME_W: u32 = 2165768223u32;
pub const PR_EMS_AB_RAS_PHONE_NUMBER: u32 = 2165702686u32;
pub const PR_EMS_AB_RAS_PHONE_NUMBER_A: u32 = 2165702686u32;
pub const PR_EMS_AB_RAS_PHONE_NUMBER_W: u32 = 2165702687u32;
pub const PR_EMS_AB_RAS_REMOTE_SRVR_NAME: u32 = 2165833758u32;
pub const PR_EMS_AB_RAS_REMOTE_SRVR_NAME_A: u32 = 2165833758u32;
pub const PR_EMS_AB_RAS_REMOTE_SRVR_NAME_W: u32 = 2165833759u32;
pub const PR_EMS_AB_REFERRAL_LIST: u32 = 2174947358u32;
pub const PR_EMS_AB_REFERRAL_LIST_A: u32 = 2174947358u32;
pub const PR_EMS_AB_REFERRAL_LIST_W: u32 = 2174947359u32;
pub const PR_EMS_AB_REGISTERED_ADDRESS: u32 = 2165903618u32;
pub const PR_EMS_AB_REMOTE_BRIDGE_HEAD: u32 = 2165964830u32;
pub const PR_EMS_AB_REMOTE_BRIDGE_HEAD_A: u32 = 2165964830u32;
pub const PR_EMS_AB_REMOTE_BRIDGE_HEAD_ADDRESS: u32 = 2166030366u32;
pub const PR_EMS_AB_REMOTE_BRIDGE_HEAD_ADDRESS_A: u32 = 2166030366u32;
pub const PR_EMS_AB_REMOTE_BRIDGE_HEAD_ADDRESS_W: u32 = 2166030367u32;
pub const PR_EMS_AB_REMOTE_BRIDGE_HEAD_W: u32 = 2165964831u32;
pub const PR_EMS_AB_REMOTE_OUT_BH_SERVER: u32 = 2166095902u32;
pub const PR_EMS_AB_REMOTE_OUT_BH_SERVER_A: u32 = 2166095902u32;
pub const PR_EMS_AB_REMOTE_OUT_BH_SERVER_O: u32 = 2166095885u32;
pub const PR_EMS_AB_REMOTE_OUT_BH_SERVER_T: u32 = 2166095902u32;
pub const PR_EMS_AB_REMOTE_OUT_BH_SERVER_W: u32 = 2166095903u32;
pub const PR_EMS_AB_REMOTE_SITE: u32 = 2166161438u32;
pub const PR_EMS_AB_REMOTE_SITE_A: u32 = 2166161438u32;
pub const PR_EMS_AB_REMOTE_SITE_O: u32 = 2166161421u32;
pub const PR_EMS_AB_REMOTE_SITE_T: u32 = 2166161438u32;
pub const PR_EMS_AB_REMOTE_SITE_W: u32 = 2166161439u32;
pub const PR_EMS_AB_REPLICATED_OBJECT_VERSION: u32 = 2355232771u32;
pub const PR_EMS_AB_REPLICATION_MAIL_MSG_SIZE: u32 = 2171076611u32;
pub const PR_EMS_AB_REPLICATION_SENSITIVITY: u32 = 2166226947u32;
pub const PR_EMS_AB_REPLICATION_SIGNATURE: u32 = 2356019458u32;
pub const PR_EMS_AB_REPLICATION_STAGGER: u32 = 2166292483u32;
pub const PR_EMS_AB_REPORTS: u32 = 2148401165u32;
pub const PR_EMS_AB_REPORTS_A: u32 = 2148405278u32;
pub const PR_EMS_AB_REPORTS_O: u32 = 2148401165u32;
pub const PR_EMS_AB_REPORTS_T: u32 = 2148405278u32;
pub const PR_EMS_AB_REPORTS_W: u32 = 2148405279u32;
pub const PR_EMS_AB_REPORT_TO_ORIGINATOR: u32 = 2166358027u32;
pub const PR_EMS_AB_REPORT_TO_OWNER: u32 = 2166423563u32;
pub const PR_EMS_AB_REQUIRE_SSL: u32 = 2351235083u32;
pub const PR_EMS_AB_REQ_SEQ: u32 = 2166489091u32;
pub const PR_EMS_AB_RESPONSIBLE_LOCAL_DXA: u32 = 2166554654u32;
pub const PR_EMS_AB_RESPONSIBLE_LOCAL_DXA_A: u32 = 2166554654u32;
pub const PR_EMS_AB_RESPONSIBLE_LOCAL_DXA_O: u32 = 2166554637u32;
pub const PR_EMS_AB_RESPONSIBLE_LOCAL_DXA_T: u32 = 2166554654u32;
pub const PR_EMS_AB_RESPONSIBLE_LOCAL_DXA_W: u32 = 2166554655u32;
pub const PR_EMS_AB_RETURN_EXACT_MSG_SIZE: u32 = 2354184203u32;
pub const PR_EMS_AB_RID_SERVER: u32 = 2166620190u32;
pub const PR_EMS_AB_RID_SERVER_A: u32 = 2166620190u32;
pub const PR_EMS_AB_RID_SERVER_O: u32 = 2166620173u32;
pub const PR_EMS_AB_RID_SERVER_T: u32 = 2166620190u32;
pub const PR_EMS_AB_RID_SERVER_W: u32 = 2166620191u32;
pub const PR_EMS_AB_ROLE_OCCUPANT: u32 = 2166689822u32;
pub const PR_EMS_AB_ROLE_OCCUPANT_A: u32 = 2166689822u32;
pub const PR_EMS_AB_ROLE_OCCUPANT_O: u32 = 2166685709u32;
pub const PR_EMS_AB_ROLE_OCCUPANT_T: u32 = 2166689822u32;
pub const PR_EMS_AB_ROLE_OCCUPANT_W: u32 = 2166689823u32;
pub const PR_EMS_AB_ROOM_CAPACITY: u32 = 134676483u32;
pub const PR_EMS_AB_ROOM_CONTAINERS: u32 = 2358644766u32;
pub const PR_EMS_AB_ROOM_CONTAINERS_A: u32 = 2358644766u32;
pub const PR_EMS_AB_ROOM_CONTAINERS_W: u32 = 2358644767u32;
pub const PR_EMS_AB_ROOM_DESCRIPTION: u32 = 134807582u32;
pub const PR_EMS_AB_ROOM_DESCRIPTION_A: u32 = 134807582u32;
pub const PR_EMS_AB_ROOM_DESCRIPTION_W: u32 = 134807583u32;
pub const PR_EMS_AB_ROOT_NEWSGROUPS_FOLDER_ID: u32 = 2175926530u32;
pub const PR_EMS_AB_ROUTING_LIST: u32 = 2166755358u32;
pub const PR_EMS_AB_ROUTING_LIST_A: u32 = 2166755358u32;
pub const PR_EMS_AB_ROUTING_LIST_W: u32 = 2166755359u32;
pub const PR_EMS_AB_RTS_CHECKPOINT_SIZE: u32 = 2166816771u32;
pub const PR_EMS_AB_RTS_RECOVERY_TIMEOUT: u32 = 2166882307u32;
pub const PR_EMS_AB_RTS_WINDOW_SIZE: u32 = 2166947843u32;
pub const PR_EMS_AB_RUNS_ON: u32 = 2167017502u32;
pub const PR_EMS_AB_RUNS_ON_A: u32 = 2167017502u32;
pub const PR_EMS_AB_RUNS_ON_O: u32 = 2167013389u32;
pub const PR_EMS_AB_RUNS_ON_T: u32 = 2167017502u32;
pub const PR_EMS_AB_RUNS_ON_W: u32 = 2167017503u32;
pub const PR_EMS_AB_SCHEMA_FLAGS: u32 = 2171797507u32;
pub const PR_EMS_AB_SCHEMA_VERSION: u32 = 2172391427u32;
pub const PR_EMS_AB_SEARCH_FLAGS: u32 = 2167209987u32;
pub const PR_EMS_AB_SEARCH_GUIDE: u32 = 2167279874u32;
pub const PR_EMS_AB_SECURITY_POLICY: u32 = 2353467650u32;
pub const PR_EMS_AB_SECURITY_PROTOCOL: u32 = 2151092482u32;
pub const PR_EMS_AB_SEE_ALSO: u32 = 2167345182u32;
pub const PR_EMS_AB_SEE_ALSO_A: u32 = 2167345182u32;
pub const PR_EMS_AB_SEE_ALSO_O: u32 = 2167341069u32;
pub const PR_EMS_AB_SEE_ALSO_T: u32 = 2167345182u32;
pub const PR_EMS_AB_SEE_ALSO_W: u32 = 2167345183u32;
pub const PR_EMS_AB_SEND_EMAIL_MESSAGE: u32 = 2352021515u32;
pub const PR_EMS_AB_SEND_TNEF: u32 = 2173763595u32;
pub const PR_EMS_AB_SENIORITY_INDEX: u32 = 2359296003u32;
pub const PR_EMS_AB_SERIAL_NUMBER: u32 = 2167410718u32;
pub const PR_EMS_AB_SERIAL_NUMBER_A: u32 = 2167410718u32;
pub const PR_EMS_AB_SERIAL_NUMBER_W: u32 = 2167410719u32;
pub const PR_EMS_AB_SERVER: u32 = 4294836254u32;
pub const PR_EMS_AB_SERVER_A: u32 = 4294836254u32;
pub const PR_EMS_AB_SERVER_W: u32 = 4294836255u32;
pub const PR_EMS_AB_SERVICE_ACTION_FIRST: u32 = 2167472131u32;
pub const PR_EMS_AB_SERVICE_ACTION_OTHER: u32 = 2167537667u32;
pub const PR_EMS_AB_SERVICE_ACTION_SECOND: u32 = 2167603203u32;
pub const PR_EMS_AB_SERVICE_RESTART_DELAY: u32 = 2167668739u32;
pub const PR_EMS_AB_SERVICE_RESTART_MESSAGE: u32 = 2167734302u32;
pub const PR_EMS_AB_SERVICE_RESTART_MESSAGE_A: u32 = 2167734302u32;
pub const PR_EMS_AB_SERVICE_RESTART_MESSAGE_W: u32 = 2167734303u32;
pub const PR_EMS_AB_SESSION_DISCONNECT_TIMER: u32 = 2167799811u32;
pub const PR_EMS_AB_SITE_AFFINITY: u32 = 2167869470u32;
pub const PR_EMS_AB_SITE_AFFINITY_A: u32 = 2167869470u32;
pub const PR_EMS_AB_SITE_AFFINITY_W: u32 = 2167869471u32;
pub const PR_EMS_AB_SITE_FOLDER_GUID: u32 = 2170945794u32;
pub const PR_EMS_AB_SITE_FOLDER_SERVER: u32 = 2171011102u32;
pub const PR_EMS_AB_SITE_FOLDER_SERVER_A: u32 = 2171011102u32;
pub const PR_EMS_AB_SITE_FOLDER_SERVER_O: u32 = 2171011085u32;
pub const PR_EMS_AB_SITE_FOLDER_SERVER_T: u32 = 2171011102u32;
pub const PR_EMS_AB_SITE_FOLDER_SERVER_W: u32 = 2171011103u32;
pub const PR_EMS_AB_SITE_PROXY_SPACE: u32 = 2167935006u32;
pub const PR_EMS_AB_SITE_PROXY_SPACE_A: u32 = 2167935006u32;
pub const PR_EMS_AB_SITE_PROXY_SPACE_W: u32 = 2167935007u32;
pub const PR_EMS_AB_SMIME_ALG_LIST_NA: u32 = 2352156702u32;
pub const PR_EMS_AB_SMIME_ALG_LIST_NA_A: u32 = 2352156702u32;
pub const PR_EMS_AB_SMIME_ALG_LIST_NA_W: u32 = 2352156703u32;
pub const PR_EMS_AB_SMIME_ALG_LIST_OTHER: u32 = 2352222238u32;
pub const PR_EMS_AB_SMIME_ALG_LIST_OTHER_A: u32 = 2352222238u32;
pub const PR_EMS_AB_SMIME_ALG_LIST_OTHER_W: u32 = 2352222239u32;
pub const PR_EMS_AB_SMIME_ALG_SELECTED_NA: u32 = 2352283678u32;
pub const PR_EMS_AB_SMIME_ALG_SELECTED_NA_A: u32 = 2352283678u32;
pub const PR_EMS_AB_SMIME_ALG_SELECTED_NA_W: u32 = 2352283679u32;
pub const PR_EMS_AB_SMIME_ALG_SELECTED_OTHER: u32 = 2352349214u32;
pub const PR_EMS_AB_SMIME_ALG_SELECTED_OTHER_A: u32 = 2352349214u32;
pub const PR_EMS_AB_SMIME_ALG_SELECTED_OTHER_W: u32 = 2352349215u32;
pub const PR_EMS_AB_SPACE_LAST_COMPUTED: u32 = 2167996480u32;
pub const PR_EMS_AB_STREET_ADDRESS: u32 = 2168061982u32;
pub const PR_EMS_AB_STREET_ADDRESS_A: u32 = 2168061982u32;
pub const PR_EMS_AB_STREET_ADDRESS_W: u32 = 2168061983u32;
pub const PR_EMS_AB_SUBMISSION_CONT_LENGTH: u32 = 2168193027u32;
pub const PR_EMS_AB_SUB_REFS: u32 = 2168131614u32;
pub const PR_EMS_AB_SUB_REFS_A: u32 = 2168131614u32;
pub const PR_EMS_AB_SUB_REFS_O: u32 = 2168127501u32;
pub const PR_EMS_AB_SUB_REFS_T: u32 = 2168131614u32;
pub const PR_EMS_AB_SUB_REFS_W: u32 = 2168131615u32;
pub const PR_EMS_AB_SUB_SITE: u32 = 2172321822u32;
pub const PR_EMS_AB_SUB_SITE_A: u32 = 2172321822u32;
pub const PR_EMS_AB_SUB_SITE_W: u32 = 2172321823u32;
pub const PR_EMS_AB_SUPPORTED_ALGORITHMS: u32 = 2354381058u32;
pub const PR_EMS_AB_SUPPORTED_APPLICATION_CONTEXT: u32 = 2168262914u32;
pub const PR_EMS_AB_SUPPORTING_STACK: u32 = 2168328222u32;
pub const PR_EMS_AB_SUPPORTING_STACK_A: u32 = 2168328222u32;
pub const PR_EMS_AB_SUPPORTING_STACK_BL: u32 = 2168393758u32;
pub const PR_EMS_AB_SUPPORTING_STACK_BL_A: u32 = 2168393758u32;
pub const PR_EMS_AB_SUPPORTING_STACK_BL_O: u32 = 2168389645u32;
pub const PR_EMS_AB_SUPPORTING_STACK_BL_T: u32 = 2168393758u32;
pub const PR_EMS_AB_SUPPORTING_STACK_BL_W: u32 = 2168393759u32;
pub const PR_EMS_AB_SUPPORTING_STACK_O: u32 = 2168324109u32;
pub const PR_EMS_AB_SUPPORTING_STACK_T: u32 = 2168328222u32;
pub const PR_EMS_AB_SUPPORTING_STACK_W: u32 = 2168328223u32;
pub const PR_EMS_AB_SUPPORT_SMIME_SIGNATURES: u32 = 2353528843u32;
pub const PR_EMS_AB_S_SELECTOR: u32 = 2167079170u32;
pub const PR_EMS_AB_S_SELECTOR_INBOUND: u32 = 2167144706u32;
pub const PR_EMS_AB_TARGET_ADDRESS: u32 = 2148597790u32;
pub const PR_EMS_AB_TARGET_ADDRESS_A: u32 = 2148597790u32;
pub const PR_EMS_AB_TARGET_ADDRESS_W: u32 = 2148597791u32;
pub const PR_EMS_AB_TARGET_MTAS: u32 = 2168590366u32;
pub const PR_EMS_AB_TARGET_MTAS_A: u32 = 2168590366u32;
pub const PR_EMS_AB_TARGET_MTAS_W: u32 = 2168590367u32;
pub const PR_EMS_AB_TELEPHONE_NUMBER: u32 = 2148667422u32;
pub const PR_EMS_AB_TELEPHONE_NUMBER_A: u32 = 2148667422u32;
pub const PR_EMS_AB_TELEPHONE_NUMBER_W: u32 = 2148667423u32;
pub const PR_EMS_AB_TELEPHONE_PERSONAL_PAGER: u32 = 2355626014u32;
pub const PR_EMS_AB_TELEPHONE_PERSONAL_PAGER_A: u32 = 2355626014u32;
pub const PR_EMS_AB_TELEPHONE_PERSONAL_PAGER_W: u32 = 2355626015u32;
pub const PR_EMS_AB_TELETEX_TERMINAL_IDENTIFIER: u32 = 2168656130u32;
pub const PR_EMS_AB_TEMP_ASSOC_THRESHOLD: u32 = 2168717315u32;
pub const PR_EMS_AB_TOMBSTONE_LIFETIME: u32 = 2168782851u32;
pub const PR_EMS_AB_TRACKING_LOG_PATH_NAME: u32 = 2168848414u32;
pub const PR_EMS_AB_TRACKING_LOG_PATH_NAME_A: u32 = 2168848414u32;
pub const PR_EMS_AB_TRACKING_LOG_PATH_NAME_W: u32 = 2168848415u32;
pub const PR_EMS_AB_TRANSFER_RETRY_INTERVAL: u32 = 2169044995u32;
pub const PR_EMS_AB_TRANSFER_TIMEOUT_NON_URGENT: u32 = 2169110531u32;
pub const PR_EMS_AB_TRANSFER_TIMEOUT_NORMAL: u32 = 2169176067u32;
pub const PR_EMS_AB_TRANSFER_TIMEOUT_URGENT: u32 = 2169241603u32;
pub const PR_EMS_AB_TRANSLATION_TABLE_USED: u32 = 2169307139u32;
pub const PR_EMS_AB_TRANSPORT_EXPEDITED_DATA: u32 = 2169372683u32;
pub const PR_EMS_AB_TRANS_RETRY_MINS: u32 = 2168913923u32;
pub const PR_EMS_AB_TRANS_TIMEOUT_MINS: u32 = 2168979459u32;
pub const PR_EMS_AB_TRUST_LEVEL: u32 = 2169438211u32;
pub const PR_EMS_AB_TURN_REQUEST_THRESHOLD: u32 = 2169503747u32;
pub const PR_EMS_AB_TWO_WAY_ALTERNATE_FACILITY: u32 = 2169569291u32;
pub const PR_EMS_AB_TYPE: u32 = 2352480286u32;
pub const PR_EMS_AB_TYPE_A: u32 = 2352480286u32;
pub const PR_EMS_AB_TYPE_W: u32 = 2352480287u32;
pub const PR_EMS_AB_T_SELECTOR: u32 = 2168455426u32;
pub const PR_EMS_AB_T_SELECTOR_INBOUND: u32 = 2168520962u32;
pub const PR_EMS_AB_UNAUTH_ORIG_BL: u32 = 2169638942u32;
pub const PR_EMS_AB_UNAUTH_ORIG_BL_A: u32 = 2169638942u32;
pub const PR_EMS_AB_UNAUTH_ORIG_BL_O: u32 = 2169634829u32;
pub const PR_EMS_AB_UNAUTH_ORIG_BL_T: u32 = 2169638942u32;
pub const PR_EMS_AB_UNAUTH_ORIG_BL_W: u32 = 2169638943u32;
pub const PR_EMS_AB_UNMERGED_ATTRIBUTES: u32 = 2356089090u32;
pub const PR_EMS_AB_USENET_SITE_NAME: u32 = 2173239326u32;
pub const PR_EMS_AB_USENET_SITE_NAME_A: u32 = 2173239326u32;
pub const PR_EMS_AB_USENET_SITE_NAME_W: u32 = 2173239327u32;
pub const PR_EMS_AB_USER_PASSWORD: u32 = 2169704706u32;
pub const PR_EMS_AB_USE_SERVER_VALUES: u32 = 2172518411u32;
pub const PR_EMS_AB_USE_SITE_VALUES: u32 = 2172846091u32;
pub const PR_EMS_AB_USN_CHANGED: u32 = 2150170627u32;
pub const PR_EMS_AB_USN_CREATED: u32 = 2169765891u32;
pub const PR_EMS_AB_USN_DSA_LAST_OBJ_REMOVED: u32 = 2169831427u32;
pub const PR_EMS_AB_USN_INTERSITE: u32 = 2172256259u32;
pub const PR_EMS_AB_USN_LAST_OBJ_REM: u32 = 2169896963u32;
pub const PR_EMS_AB_USN_SOURCE: u32 = 2169962499u32;
pub const PR_EMS_AB_VIEW_CONTAINER_1: u32 = 2176778270u32;
pub const PR_EMS_AB_VIEW_CONTAINER_1_A: u32 = 2176778270u32;
pub const PR_EMS_AB_VIEW_CONTAINER_1_W: u32 = 2176778271u32;
pub const PR_EMS_AB_VIEW_CONTAINER_2: u32 = 2176843806u32;
pub const PR_EMS_AB_VIEW_CONTAINER_2_A: u32 = 2176843806u32;
pub const PR_EMS_AB_VIEW_CONTAINER_2_W: u32 = 2176843807u32;
pub const PR_EMS_AB_VIEW_CONTAINER_3: u32 = 2176909342u32;
pub const PR_EMS_AB_VIEW_CONTAINER_3_A: u32 = 2176909342u32;
pub const PR_EMS_AB_VIEW_CONTAINER_3_W: u32 = 2176909343u32;
pub const PR_EMS_AB_VIEW_DEFINITION: u32 = 2350584066u32;
pub const PR_EMS_AB_VIEW_FLAGS: u32 = 2350383107u32;
pub const PR_EMS_AB_VIEW_SITE: u32 = 2176712734u32;
pub const PR_EMS_AB_VIEW_SITE_A: u32 = 2176712734u32;
pub const PR_EMS_AB_VIEW_SITE_W: u32 = 2176712735u32;
pub const PR_EMS_AB_VOICE_MAIL_FLAGS: u32 = 2353008898u32;
pub const PR_EMS_AB_VOICE_MAIL_GREETINGS: u32 = 2352943134u32;
pub const PR_EMS_AB_VOICE_MAIL_GREETINGS_A: u32 = 2352943134u32;
pub const PR_EMS_AB_VOICE_MAIL_GREETINGS_W: u32 = 2352943135u32;
pub const PR_EMS_AB_VOICE_MAIL_PASSWORD: u32 = 2352807966u32;
pub const PR_EMS_AB_VOICE_MAIL_PASSWORD_A: u32 = 2352807966u32;
pub const PR_EMS_AB_VOICE_MAIL_PASSWORD_W: u32 = 2352807967u32;
pub const PR_EMS_AB_VOICE_MAIL_RECORDED_NAME: u32 = 2352873730u32;
pub const PR_EMS_AB_VOICE_MAIL_RECORDING_LENGTH: u32 = 2353205251u32;
pub const PR_EMS_AB_VOICE_MAIL_SPEED: u32 = 2353135619u32;
pub const PR_EMS_AB_VOICE_MAIL_SYSTEM_GUID: u32 = 2352677122u32;
pub const PR_EMS_AB_VOICE_MAIL_USER_ID: u32 = 2352742430u32;
pub const PR_EMS_AB_VOICE_MAIL_USER_ID_A: u32 = 2352742430u32;
pub const PR_EMS_AB_VOICE_MAIL_USER_ID_W: u32 = 2352742431u32;
pub const PR_EMS_AB_VOICE_MAIL_VOLUME: u32 = 2353070083u32;
pub const PR_EMS_AB_WWW_HOME_PAGE: u32 = 2171928606u32;
pub const PR_EMS_AB_WWW_HOME_PAGE_A: u32 = 2171928606u32;
pub const PR_EMS_AB_WWW_HOME_PAGE_W: u32 = 2171928607u32;
pub const PR_EMS_AB_X121_ADDRESS: u32 = 2170032158u32;
pub const PR_EMS_AB_X121_ADDRESS_A: u32 = 2170032158u32;
pub const PR_EMS_AB_X121_ADDRESS_W: u32 = 2170032159u32;
pub const PR_EMS_AB_X25_CALL_USER_DATA_INCOMING: u32 = 2170093826u32;
pub const PR_EMS_AB_X25_CALL_USER_DATA_OUTGOING: u32 = 2170159362u32;
pub const PR_EMS_AB_X25_FACILITIES_DATA_INCOMING: u32 = 2170224898u32;
pub const PR_EMS_AB_X25_FACILITIES_DATA_OUTGOING: u32 = 2170290434u32;
pub const PR_EMS_AB_X25_LEASED_LINE_PORT: u32 = 2170355970u32;
pub const PR_EMS_AB_X25_LEASED_OR_SWITCHED: u32 = 2170421259u32;
pub const PR_EMS_AB_X25_REMOTE_MTA_PHONE: u32 = 2170486814u32;
pub const PR_EMS_AB_X25_REMOTE_MTA_PHONE_A: u32 = 2170486814u32;
pub const PR_EMS_AB_X25_REMOTE_MTA_PHONE_W: u32 = 2170486815u32;
pub const PR_EMS_AB_X400_ATTACHMENT_TYPE: u32 = 2170552578u32;
pub const PR_EMS_AB_X400_SELECTOR_SYNTAX: u32 = 2170617859u32;
pub const PR_EMS_AB_X500_ACCESS_CONTROL_LIST: u32 = 2170683650u32;
pub const PR_EMS_AB_X500_NC: u32 = 2174877726u32;
pub const PR_EMS_AB_X500_NC_A: u32 = 2174877726u32;
pub const PR_EMS_AB_X500_NC_W: u32 = 2174877727u32;
pub const PR_EMS_AB_X500_RDN: u32 = 2174812190u32;
pub const PR_EMS_AB_X500_RDN_A: u32 = 2174812190u32;
pub const PR_EMS_AB_X500_RDN_W: u32 = 2174812191u32;
pub const PR_EMS_AB_X509_CERT: u32 = 2355761410u32;
pub const PR_EMS_AB_XMIT_TIMEOUT_NON_URGENT: u32 = 2170748931u32;
pub const PR_EMS_AB_XMIT_TIMEOUT_NORMAL: u32 = 2170814467u32;
pub const PR_EMS_AB_XMIT_TIMEOUT_URGENT: u32 = 2170880003u32;
pub const PR_END_DATE: u32 = 6357056u32;
pub const PR_ENTRYID: u32 = 268370178u32;
pub const PR_EVENTS_ROOT_FOLDER_ENTRYID: u32 = 1719271682u32;
pub const PR_EXCESS_STORAGE_USED: u32 = 1073086467u32;
pub const PR_EXPIRY_NUMBER: u32 = 1072496643u32;
pub const PR_EXPIRY_TIME: u32 = 1376320u32;
pub const PR_EXPIRY_UNITS: u32 = 1072562179u32;
pub const PR_EXPLICIT_CONVERSION: u32 = 201392131u32;
pub const PR_EXTENDED_ACL_DATA: u32 = 1073611010u32;
pub const PR_EXTENDED_RULE_ACTIONS: u32 = 244908290u32;
pub const PR_EXTENDED_RULE_CONDITION: u32 = 244973826u32;
pub const PR_EXTENDED_RULE_MSG_ACTIONS: u32 = 244908290u32;
pub const PR_EXTENDED_RULE_MSG_CONDITION: u32 = 244973826u32;
pub const PR_EXTENDED_RULE_SIZE_LIMIT: u32 = 245039107u32;
pub const PR_FAST_TRANSFER: u32 = 1714356237u32;
pub const PR_FAVORITES_DEFAULT_NAME: u32 = 1714749470u32;
pub const PR_FAVORITES_DEFAULT_NAME_W: u32 = 1714749471u32;
pub const PR_FID_VID: u32 = 1716257026u32;
pub const PR_FILE_SIZE: u32 = 1732706307u32;
pub const PR_FILE_SIZE_EXTENDED: u32 = 1732706324u32;
pub const PR_FILTERING_HOOKS: u32 = 1023934722u32;
pub const PR_FINDER_ENTRYID: u32 = 904331522u32;
pub const PR_FLAG_STATUS: u32 = 277872643u32;
pub const PR_FLAT_URL_NAME: u32 = 1728970782u32;
pub const PR_FLAT_URL_NAME_A: u32 = 1728970782u32;
pub const PR_FLAT_URL_NAME_W: u32 = 1728970783u32;
pub const PR_FOLDER_ASSOCIATED_CONTENTS: u32 = 907018253u32;
pub const PR_FOLDER_CHILD_COUNT: u32 = 1714946051u32;
pub const PR_FOLDER_DESIGN_FLAGS: u32 = 1071775747u32;
pub const PR_FOLDER_FLAGS: u32 = 1722286083u32;
pub const PR_FOLDER_PATHNAME: u32 = 1723138078u32;
pub const PR_FOLDER_PATHNAME_A: u32 = 1723138078u32;
pub const PR_FOLDER_PATHNAME_W: u32 = 1723138079u32;
pub const PR_FOLDER_TYPE: u32 = 906035203u32;
pub const PR_FORCE_CLIENT_REFRESH: u32 = 1705050123u32;
pub const PR_FOREIGN_ID: u32 = 1718026498u32;
pub const PR_FOREIGN_REPORT_ID: u32 = 1718092034u32;
pub const PR_FOREIGN_SUBJECT_ID: u32 = 1718157570u32;
pub const PR_FORM_CATEGORY: u32 = 855900190u32;
pub const PR_FORM_CATEGORY_A: u32 = 855900190u32;
pub const PR_FORM_CATEGORY_SUB: u32 = 855965726u32;
pub const PR_FORM_CATEGORY_SUB_A: u32 = 855965726u32;
pub const PR_FORM_CATEGORY_SUB_W: u32 = 855965727u32;
pub const PR_FORM_CATEGORY_W: u32 = 855900191u32;
pub const PR_FORM_CLSID: u32 = 855769160u32;
pub const PR_FORM_CONTACT_NAME: u32 = 855834654u32;
pub const PR_FORM_CONTACT_NAME_A: u32 = 855834654u32;
pub const PR_FORM_CONTACT_NAME_W: u32 = 855834655u32;
pub const PR_FORM_DESIGNER_GUID: u32 = 856227912u32;
pub const PR_FORM_DESIGNER_NAME: u32 = 856162334u32;
pub const PR_FORM_DESIGNER_NAME_A: u32 = 856162334u32;
pub const PR_FORM_DESIGNER_NAME_W: u32 = 856162335u32;
pub const PR_FORM_HIDDEN: u32 = 856096779u32;
pub const PR_FORM_HOST_MAP: u32 = 856035331u32;
pub const PR_FORM_MESSAGE_BEHAVIOR: u32 = 856293379u32;
pub const PR_FORM_VERSION: u32 = 855703582u32;
pub const PR_FORM_VERSION_A: u32 = 855703582u32;
pub const PR_FORM_VERSION_W: u32 = 855703583u32;
pub const PR_FREE_BUSY_FOR_LOCAL_SITE_ENTRYID: u32 = 1713701122u32;
pub const PR_FTP_SITE: u32 = 978059294u32;
pub const PR_FTP_SITE_A: u32 = 978059294u32;
pub const PR_FTP_SITE_W: u32 = 978059295u32;
pub const PR_GENDER: u32 = 978124802u32;
pub const PR_GENERATION: u32 = 973406238u32;
pub const PR_GENERATION_A: u32 = 973406238u32;
pub const PR_GENERATION_W: u32 = 973406239u32;
pub const PR_GET_PROPS_EXCLUDE_PROP_ID_LIST: u32 = 1719533826u32;
pub const PR_GIVEN_NAME: u32 = 973471774u32;
pub const PR_GIVEN_NAME_A: u32 = 973471774u32;
pub const PR_GIVEN_NAME_W: u32 = 973471775u32;
pub const PR_GOVERNMENT_ID_NUMBER: u32 = 973537310u32;
pub const PR_GOVERNMENT_ID_NUMBER_A: u32 = 973537310u32;
pub const PR_GOVERNMENT_ID_NUMBER_W: u32 = 973537311u32;
pub const PR_GW_ADMIN_OPERATIONS: u32 = 1717043203u32;
pub const PR_GW_MTSIN_ENTRYID: u32 = 1713897730u32;
pub const PR_GW_MTSOUT_ENTRYID: u32 = 1713963266u32;
pub const PR_HASATTACH: u32 = 236650507u32;
pub const PR_HAS_DAMS: u32 = 1072300043u32;
pub const PR_HAS_MODERATOR_RULES: u32 = 1715404811u32;
pub const PR_HAS_NAMED_PROPERTIES: u32 = 1716125707u32;
pub const PR_HAS_RULES: u32 = 1715077131u32;
pub const PR_HEADER_FOLDER_ENTRYID: u32 = 1040843010u32;
pub const PR_HIERARCHY_CHANGE_NUM: u32 = 1715339267u32;
pub const PR_HIERARCHY_SERVER: u32 = 1714618398u32;
pub const PR_HIERARCHY_SYNCHRONIZER: u32 = 1714159629u32;
pub const PR_HOBBIES: u32 = 977469470u32;
pub const PR_HOBBIES_A: u32 = 977469470u32;
pub const PR_HOBBIES_W: u32 = 977469471u32;
pub const PR_HOME2_TELEPHONE_NUMBER: u32 = 976158750u32;
pub const PR_HOME2_TELEPHONE_NUMBER_A: u32 = 976158750u32;
pub const PR_HOME2_TELEPHONE_NUMBER_W: u32 = 976158751u32;
pub const PR_HOME_ADDRESS_CITY: u32 = 978911262u32;
pub const PR_HOME_ADDRESS_CITY_A: u32 = 978911262u32;
pub const PR_HOME_ADDRESS_CITY_W: u32 = 978911263u32;
pub const PR_HOME_ADDRESS_COUNTRY: u32 = 978976798u32;
pub const PR_HOME_ADDRESS_COUNTRY_A: u32 = 978976798u32;
pub const PR_HOME_ADDRESS_COUNTRY_W: u32 = 978976799u32;
pub const PR_HOME_ADDRESS_POSTAL_CODE: u32 = 979042334u32;
pub const PR_HOME_ADDRESS_POSTAL_CODE_A: u32 = 979042334u32;
pub const PR_HOME_ADDRESS_POSTAL_CODE_W: u32 = 979042335u32;
pub const PR_HOME_ADDRESS_POST_OFFICE_BOX: u32 = 979238942u32;
pub const PR_HOME_ADDRESS_POST_OFFICE_BOX_A: u32 = 979238942u32;
pub const PR_HOME_ADDRESS_POST_OFFICE_BOX_W: u32 = 979238943u32;
pub const PR_HOME_ADDRESS_STATE_OR_PROVINCE: u32 = 979107870u32;
pub const PR_HOME_ADDRESS_STATE_OR_PROVINCE_A: u32 = 979107870u32;
pub const PR_HOME_ADDRESS_STATE_OR_PROVINCE_W: u32 = 979107871u32;
pub const PR_HOME_ADDRESS_STREET: u32 = 979173406u32;
pub const PR_HOME_ADDRESS_STREET_A: u32 = 979173406u32;
pub const PR_HOME_ADDRESS_STREET_W: u32 = 979173407u32;
pub const PR_HOME_FAX_NUMBER: u32 = 975503390u32;
pub const PR_HOME_FAX_NUMBER_A: u32 = 975503390u32;
pub const PR_HOME_FAX_NUMBER_W: u32 = 975503391u32;
pub const PR_HOME_TELEPHONE_NUMBER: u32 = 973668382u32;
pub const PR_HOME_TELEPHONE_NUMBER_A: u32 = 973668382u32;
pub const PR_HOME_TELEPHONE_NUMBER_W: u32 = 973668383u32;
pub const PR_HTML: u32 = 269680898u32;
pub const PR_ICON: u32 = 268239106u32;
pub const PR_ICON_INDEX: u32 = 276824067u32;
pub const PR_ICS_CHANGE_KEY: u32 = 1716846850u32;
pub const PR_IDENTITY_DISPLAY: u32 = 1040187422u32;
pub const PR_IDENTITY_DISPLAY_A: u32 = 1040187422u32;
pub const PR_IDENTITY_DISPLAY_W: u32 = 1040187423u32;
pub const PR_IDENTITY_ENTRYID: u32 = 1040253186u32;
pub const PR_IDENTITY_SEARCH_KEY: u32 = 1040515330u32;
pub const PR_IMAP_INTERNAL_DATE: u32 = 1710555200u32;
pub const PR_IMPLICIT_CONVERSION_PROHIBITED: u32 = 1441803u32;
pub const PR_IMPLIED_RESTRICTIONS: u32 = 1719603458u32;
pub const PR_IMPORTANCE: u32 = 1507331u32;
pub const PR_INBOUND_NEWSFEED_DN: u32 = 1720516638u32;
pub const PR_INCOMPLETE_COPY: u32 = 3473419u32;
pub const PR_INITIALS: u32 = 973733918u32;
pub const PR_INITIALS_A: u32 = 973733918u32;
pub const PR_INITIALS_W: u32 = 973733919u32;
pub const PR_INITIAL_DETAILS_PANE: u32 = 1057488899u32;
pub const PR_INSTANCE_KEY: u32 = 267780354u32;
pub const PR_INTERNAL_TRACE_INFO: u32 = 1718223106u32;
pub const PR_INTERNET_CHARSET: u32 = 1721368606u32;
pub const PR_INTERNET_CONTENT: u32 = 1717108994u32;
pub const PR_INTERNET_CONTENT_EA: u32 = 1717108996u32;
pub const PR_INTERNET_CONTENT_HANDLE: u32 = 1717108995u32;
pub const PR_INTERNET_CPID: u32 = 1071513603u32;
pub const PR_INTERNET_MDNS: u32 = 1722089483u32;
pub const PR_INTERNET_MESSAGE_ID: u32 = 271908894u32;
pub const PR_INTERNET_MESSAGE_ID_A: u32 = 271908894u32;
pub const PR_INTERNET_MESSAGE_ID_W: u32 = 271908895u32;
pub const PR_INTERNET_NEWSGROUP_NAME: u32 = 1722220574u32;
pub const PR_INTERNET_NEWSGROUP_NAME_A: u32 = 1722220574u32;
pub const PR_INTERNET_NEWSGROUP_NAME_W: u32 = 1722220575u32;
pub const PR_INTERNET_REFERENCES: u32 = 272171038u32;
pub const PR_INTERNET_REFERENCES_A: u32 = 272171038u32;
pub const PR_INTERNET_REFERENCES_W: u32 = 272171039u32;
pub const PR_IN_CONFLICT: u32 = 1718353931u32;
pub const PR_IN_REPLY_TO: u32 = 272760862u32;
pub const PR_IN_REPLY_TO_A: u32 = 272760862u32;
pub const PR_IN_REPLY_TO_W: u32 = 272760863u32;
pub const PR_IN_TRANSIT: u32 = 1712848907u32;
pub const PR_IPM_APPOINTMENT_ENTRYID: u32 = 919601410u32;
pub const PR_IPM_ARCHIVE_ENTRYID: u32 = 905904386u32;
pub const PR_IPM_CONTACT_ENTRYID: u32 = 919666946u32;
pub const PR_IPM_DAF_ENTRYID: u32 = 1713307906u32;
pub const PR_IPM_DRAFTS_ENTRYID: u32 = 920060162u32;
pub const PR_IPM_FAVORITES_ENTRYID: u32 = 1714422018u32;
pub const PR_IPM_ID: u32 = 1573122u32;
pub const PR_IPM_OUTBOX_ENTRYID: u32 = 904003842u32;
pub const PR_IPM_OUTBOX_SEARCH_KEY: u32 = 873529602u32;
pub const PR_IPM_PUBLIC_FOLDERS_ENTRYID: u32 = 1714487554u32;
pub const PR_IPM_RETURN_REQUESTED: u32 = 201457675u32;
pub const PR_IPM_SENTMAIL_ENTRYID: u32 = 904134914u32;
pub const PR_IPM_SENTMAIL_SEARCH_KEY: u32 = 873660674u32;
pub const PR_IPM_SUBTREE_ENTRYID: u32 = 903872770u32;
pub const PR_IPM_SUBTREE_SEARCH_KEY: u32 = 873464066u32;
pub const PR_IPM_TASK_ENTRYID: u32 = 919863554u32;
pub const PR_IPM_WASTEBASKET_ENTRYID: u32 = 904069378u32;
pub const PR_IPM_WASTEBASKET_SEARCH_KEY: u32 = 873595138u32;
pub const PR_ISDN_NUMBER: u32 = 976027678u32;
pub const PR_ISDN_NUMBER_A: u32 = 976027678u32;
pub const PR_ISDN_NUMBER_W: u32 = 976027679u32;
pub const PR_IS_NEWSGROUP: u32 = 1721171979u32;
pub const PR_IS_NEWSGROUP_ANCHOR: u32 = 1721106443u32;
pub const PR_ITEM_LEVEL_ACL: u32 = 1025769483u32;
pub const PR_KEYWORD: u32 = 973799454u32;
pub const PR_KEYWORD_A: u32 = 973799454u32;
pub const PR_KEYWORD_W: u32 = 973799455u32;
pub const PR_LANGUAGE: u32 = 973864990u32;
pub const PR_LANGUAGES: u32 = 3080222u32;
pub const PR_LANGUAGES_A: u32 = 3080222u32;
pub const PR_LANGUAGES_W: u32 = 3080223u32;
pub const PR_LANGUAGE_A: u32 = 973864990u32;
pub const PR_LANGUAGE_W: u32 = 973864991u32;
pub const PR_LAST_ACCESS_TIME: u32 = 1722351680u32;
pub const PR_LAST_FULL_BACKUP: u32 = 1719992384u32;
pub const PR_LAST_LOGOFF_TIME: u32 = 1721958464u32;
pub const PR_LAST_LOGON_TIME: u32 = 1721892928u32;
pub const PR_LAST_MODIFICATION_TIME: u32 = 805830720u32;
pub const PR_LAST_MODIFIER_ENTRYID: u32 = 1073414402u32;
pub const PR_LAST_MODIFIER_NAME: u32 = 1073348638u32;
pub const PR_LAST_MODIFIER_NAME_A: u32 = 1073348638u32;
pub const PR_LAST_MODIFIER_NAME_W: u32 = 1073348639u32;
pub const PR_LAST_MODIFIER_SID: u32 = 240713986u32;
pub const PR_LAST_MODIFIER_SID_AS_XML: u32 = 242024478u32;
pub const PR_LATEST_DELIVERY_TIME: u32 = 1638464u32;
pub const PR_LOCALE_ID: u32 = 1721827331u32;
pub const PR_LOCALITY: u32 = 975634462u32;
pub const PR_LOCALITY_A: u32 = 975634462u32;
pub const PR_LOCALITY_W: u32 = 975634463u32;
pub const PR_LOCAL_COMMIT_TIME: u32 = 1728643136u32;
pub const PR_LOCAL_COMMIT_TIME_MAX: u32 = 1728708672u32;
pub const PR_LOCATION: u32 = 973930526u32;
pub const PR_LOCATION_A: u32 = 973930526u32;
pub const PR_LOCATION_W: u32 = 973930527u32;
pub const PR_LOCK_BRANCH_ID: u32 = 939524116u32;
pub const PR_LOCK_DEPTH: u32 = 940048387u32;
pub const PR_LOCK_ENLISTMENT_CONTEXT: u32 = 939786498u32;
pub const PR_LOCK_EXPIRY_TIME: u32 = 940179520u32;
pub const PR_LOCK_GLID: u32 = 940245250u32;
pub const PR_LOCK_NULL_URL_W: u32 = 940310559u32;
pub const PR_LOCK_RESOURCE_DID: u32 = 939655188u32;
pub const PR_LOCK_RESOURCE_FID: u32 = 939589652u32;
pub const PR_LOCK_RESOURCE_VID: u32 = 939720724u32;
pub const PR_LOCK_SCOPE: u32 = 939917314u32;
pub const PR_LOCK_TIMEOUT: u32 = 940113923u32;
pub const PR_LOCK_TRANSIENT_ID: u32 = 939983106u32;
pub const PR_LOCK_TYPE: u32 = 939851778u32;
pub const PR_LONGTERM_ENTRYID_FROM_TABLE: u32 = 1718616322u32;
pub const PR_MAILBOX_OWNER_ENTRYID: u32 = 1713045762u32;
pub const PR_MAILBOX_OWNER_NAME: u32 = 1713111070u32;
pub const PR_MAILBOX_OWNER_NAME_A: u32 = 1713111070u32;
pub const PR_MAILBOX_OWNER_NAME_W: u32 = 1713111071u32;
pub const PR_MAIL_PERMISSION: u32 = 973996043u32;
pub const PR_MANAGER_NAME: u32 = 978190366u32;
pub const PR_MANAGER_NAME_A: u32 = 978190366u32;
pub const PR_MANAGER_NAME_W: u32 = 978190367u32;
pub const PR_MAPPING_SIGNATURE: u32 = 267911426u32;
pub const PR_MAX_CACHED_VIEWS: u32 = 241696771u32;
pub const PR_MAX_INDICES: u32 = 241041411u32;
pub const PR_MAX_SUBMIT_MESSAGE_SIZE: u32 = 1718419459u32;
pub const PR_MDB_PROVIDER: u32 = 873726210u32;
pub const PR_MEMBER_ID: u32 = 1718681620u32;
pub const PR_MEMBER_NAME: u32 = 1718747166u32;
pub const PR_MEMBER_NAME_A: u32 = 1718747166u32;
pub const PR_MEMBER_NAME_W: u32 = 1718747167u32;
pub const PR_MEMBER_RIGHTS: u32 = 1718812675u32;
pub const PR_MERGE_MIDSET_DELETED: u32 = 242876674u32;
pub const PR_MESSAGE_ATTACHMENTS: u32 = 236126221u32;
pub const PR_MESSAGE_CC_ME: u32 = 5767179u32;
pub const PR_MESSAGE_CLASS: u32 = 1703966u32;
pub const PR_MESSAGE_CLASS_A: u32 = 1703966u32;
pub const PR_MESSAGE_CLASS_W: u32 = 1703967u32;
pub const PR_MESSAGE_CODEPAGE: u32 = 1073545219u32;
pub const PR_MESSAGE_DELIVERY_ID: u32 = 1769730u32;
pub const PR_MESSAGE_DELIVERY_TIME: u32 = 235274304u32;
pub const PR_MESSAGE_DOWNLOAD_TIME: u32 = 236453891u32;
pub const PR_MESSAGE_FLAGS: u32 = 235339779u32;
pub const PR_MESSAGE_LOCALE_ID: u32 = 1072758787u32;
pub const PR_MESSAGE_PROCESSED: u32 = 1709703179u32;
pub const PR_MESSAGE_RECIPIENTS: u32 = 236060685u32;
pub const PR_MESSAGE_RECIP_ME: u32 = 5832715u32;
pub const PR_MESSAGE_SECURITY_LABEL: u32 = 1966338u32;
pub const PR_MESSAGE_SITE_NAME: u32 = 1709637662u32;
pub const PR_MESSAGE_SITE_NAME_A: u32 = 1709637662u32;
pub const PR_MESSAGE_SITE_NAME_W: u32 = 1709637663u32;
pub const PR_MESSAGE_SIZE: u32 = 235405315u32;
pub const PR_MESSAGE_SIZE_EXTENDED: u32 = 235405332u32;
pub const PR_MESSAGE_SUBMISSION_ID: u32 = 4653314u32;
pub const PR_MESSAGE_TOKEN: u32 = 201523458u32;
pub const PR_MESSAGE_TO_ME: u32 = 5701643u32;
pub const PR_MHS_COMMON_NAME: u32 = 974061598u32;
pub const PR_MHS_COMMON_NAME_A: u32 = 974061598u32;
pub const PR_MHS_COMMON_NAME_W: u32 = 974061599u32;
pub const PR_MIDDLE_NAME: u32 = 977535006u32;
pub const PR_MIDDLE_NAME_A: u32 = 977535006u32;
pub const PR_MIDDLE_NAME_W: u32 = 977535007u32;
pub const PR_MIME_SIZE: u32 = 1732640771u32;
pub const PR_MIME_SIZE_EXTENDED: u32 = 1732640788u32;
pub const PR_MINI_ICON: u32 = 268173570u32;
pub const PR_MOBILE_TELEPHONE_NUMBER: u32 = 974913566u32;
pub const PR_MOBILE_TELEPHONE_NUMBER_A: u32 = 974913566u32;
pub const PR_MOBILE_TELEPHONE_NUMBER_W: u32 = 974913567u32;
pub const PR_MODIFY_VERSION: u32 = 236584980u32;
pub const PR_MOVE_TO_FOLDER_ENTRYID: u32 = 1072955650u32;
pub const PR_MOVE_TO_STORE_ENTRYID: u32 = 1072890114u32;
pub const PR_MSG_BODY_ID: u32 = 1071448067u32;
pub const PR_MSG_EDITOR_FORMAT: u32 = 1493762051u32;
pub const PR_MSG_FOLD_TIME: u32 = 1716781120u32;
pub const PR_MSG_STATUS: u32 = 236388355u32;
pub const PR_MTS_SUBJECT_ID: u32 = 1717764354u32;
pub const PR_NATIVE_BODY_INFO: u32 = 269877251u32;
pub const PR_NDR_DIAG_CODE: u32 = 201654275u32;
pub const PR_NDR_REASON_CODE: u32 = 201588739u32;
pub const PR_NEWSFEED_INFO: u32 = 1722155266u32;
pub const PR_NEWSGROUP_COMPONENT: u32 = 1722089502u32;
pub const PR_NEWSGROUP_ROOT_FOLDER_ENTRYID: u32 = 1720451330u32;
pub const PR_NEW_SUBS_GET_AUTO_ADD: u32 = 1709572107u32;
pub const PR_NEXT_SEND_ACCT: u32 = 237568031u32;
pub const PR_NICKNAME: u32 = 978255902u32;
pub const PR_NICKNAME_A: u32 = 978255902u32;
pub const PR_NICKNAME_W: u32 = 978255903u32;
pub const PR_NNTP_ARTICLE_FOLDER_ENTRYID: u32 = 1720320258u32;
pub const PR_NNTP_CONTROL_FOLDER_ENTRYID: u32 = 1720385794u32;
pub const PR_NON_IPM_SUBTREE_ENTRYID: u32 = 1713373442u32;
pub const PR_NON_RECEIPT_NOTIFICATION_REQUESTED: u32 = 201719819u32;
pub const PR_NON_RECEIPT_REASON: u32 = 4063235u32;
pub const PR_NON_WIN32_ACL: u32 = 1025703947u32;
pub const PR_NON_XMT_SECURITY_ROLE_1: u32 = 243007746u32;
pub const PR_NON_XMT_SECURITY_ROLE_1_AS_XML: u32 = 243007518u32;
pub const PR_NON_XMT_SECURITY_ROLE_2: u32 = 243073282u32;
pub const PR_NON_XMT_SECURITY_ROLE_2_AS_XML: u32 = 243073054u32;
pub const PR_NON_XMT_SECURITY_ROLE_3: u32 = 243138818u32;
pub const PR_NON_XMT_SECURITY_ROLE_3_AS_XML: u32 = 243138590u32;
pub const PR_NON_XMT_SECURITY_ROLE_4: u32 = 243204354u32;
pub const PR_NON_XMT_SECURITY_ROLE_4_AS_XML: u32 = 243204126u32;
pub const PR_NON_XMT_SECURITY_ROLE_5: u32 = 243269890u32;
pub const PR_NON_XMT_SECURITY_ROLE_5_AS_XML: u32 = 243269662u32;
pub const PR_NON_XMT_SECURITY_ROLE_6: u32 = 243335426u32;
pub const PR_NON_XMT_SECURITY_ROLE_6_AS_XML: u32 = 243335198u32;
pub const PR_NON_XMT_SECURITY_ROLE_7: u32 = 243400962u32;
pub const PR_NON_XMT_SECURITY_ROLE_7_AS_XML: u32 = 243400734u32;
pub const PR_NON_XMT_SECURITY_ROLE_8: u32 = 243466498u32;
pub const PR_NON_XMT_SECURITY_ROLE_8_AS_XML: u32 = 243466270u32;
pub const PR_NORMALIZED_SUBJECT: u32 = 236781598u32;
pub const PR_NORMALIZED_SUBJECT_A: u32 = 236781598u32;
pub const PR_NORMALIZED_SUBJECT_W: u32 = 236781599u32;
pub const PR_NORMAL_MESSAGE_SIZE: u32 = 1723006979u32;
pub const PR_NORMAL_MESSAGE_SIZE_EXTENDED: u32 = 1723006996u32;
pub const PR_NORMAL_MSG_W_ATTACH_COUNT: u32 = 1722613763u32;
pub const PR_NT_SECURITY_DESCRIPTOR_AS_XML: u32 = 241827870u32;
pub const PR_NT_SECURITY_DESCRIPTOR_AS_XML_A: u32 = 241827870u32;
pub const PR_NT_SECURITY_DESCRIPTOR_AS_XML_W: u32 = 241827871u32;
pub const PR_NT_USER_NAME: u32 = 1721761822u32;
pub const PR_NULL: u32 = 1u32;
pub const PR_OBJECT_TYPE: u32 = 268304387u32;
pub const PR_OBSOLETED_IPMS: u32 = 2031874u32;
pub const PR_OFFICE2_TELEPHONE_NUMBER: u32 = 974848030u32;
pub const PR_OFFICE2_TELEPHONE_NUMBER_A: u32 = 974848030u32;
pub const PR_OFFICE2_TELEPHONE_NUMBER_W: u32 = 974848031u32;
pub const PR_OFFICE_LOCATION: u32 = 974716958u32;
pub const PR_OFFICE_LOCATION_A: u32 = 974716958u32;
pub const PR_OFFICE_LOCATION_W: u32 = 974716959u32;
pub const PR_OFFICE_TELEPHONE_NUMBER: u32 = 973602846u32;
pub const PR_OFFICE_TELEPHONE_NUMBER_A: u32 = 973602846u32;
pub const PR_OFFICE_TELEPHONE_NUMBER_W: u32 = 973602847u32;
pub const PR_OFFLINE_ADDRBOOK_ENTRYID: u32 = 1713570050u32;
pub const PR_OFFLINE_FLAGS: u32 = 1715273731u32;
pub const PR_OFFLINE_MESSAGE_ENTRYID: u32 = 1713832194u32;
pub const PR_OLDEST_DELETED_ON: u32 = 1715601472u32;
pub const PR_OOF_STATE: u32 = 1713176587u32;
pub const PR_ORGANIZATIONAL_ID_NUMBER: u32 = 974127134u32;
pub const PR_ORGANIZATIONAL_ID_NUMBER_A: u32 = 974127134u32;
pub const PR_ORGANIZATIONAL_ID_NUMBER_W: u32 = 974127135u32;
pub const PR_ORIGINALLY_INTENDED_RECIPIENT_NAME: u32 = 2097410u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_ADDRTYPE: u32 = 8060958u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_ADDRTYPE_A: u32 = 8060958u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_ADDRTYPE_W: u32 = 8060959u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_EMAIL_ADDRESS: u32 = 8126494u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_EMAIL_ADDRESS_A: u32 = 8126494u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_EMAIL_ADDRESS_W: u32 = 8126495u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_ENTRYID: u32 = 269615362u32;
pub const PR_ORIGINAL_AUTHOR_ADDRTYPE: u32 = 7929886u32;
pub const PR_ORIGINAL_AUTHOR_ADDRTYPE_A: u32 = 7929886u32;
pub const PR_ORIGINAL_AUTHOR_ADDRTYPE_W: u32 = 7929887u32;
pub const PR_ORIGINAL_AUTHOR_EMAIL_ADDRESS: u32 = 7995422u32;
pub const PR_ORIGINAL_AUTHOR_EMAIL_ADDRESS_A: u32 = 7995422u32;
pub const PR_ORIGINAL_AUTHOR_EMAIL_ADDRESS_W: u32 = 7995423u32;
pub const PR_ORIGINAL_AUTHOR_ENTRYID: u32 = 4980994u32;
pub const PR_ORIGINAL_AUTHOR_NAME: u32 = 5046302u32;
pub const PR_ORIGINAL_AUTHOR_NAME_A: u32 = 5046302u32;
pub const PR_ORIGINAL_AUTHOR_NAME_W: u32 = 5046303u32;
pub const PR_ORIGINAL_AUTHOR_SEARCH_KEY: u32 = 5636354u32;
pub const PR_ORIGINAL_AUTHOR_SID: u32 = 240451842u32;
pub const PR_ORIGINAL_AUTHOR_SID_AS_XML: u32 = 242614302u32;
pub const PR_ORIGINAL_DELIVERY_TIME: u32 = 5570624u32;
pub const PR_ORIGINAL_DISPLAY_BCC: u32 = 7471134u32;
pub const PR_ORIGINAL_DISPLAY_BCC_A: u32 = 7471134u32;
pub const PR_ORIGINAL_DISPLAY_BCC_W: u32 = 7471135u32;
pub const PR_ORIGINAL_DISPLAY_CC: u32 = 7536670u32;
pub const PR_ORIGINAL_DISPLAY_CC_A: u32 = 7536670u32;
pub const PR_ORIGINAL_DISPLAY_CC_W: u32 = 7536671u32;
pub const PR_ORIGINAL_DISPLAY_NAME: u32 = 974323742u32;
pub const PR_ORIGINAL_DISPLAY_NAME_A: u32 = 974323742u32;
pub const PR_ORIGINAL_DISPLAY_NAME_W: u32 = 974323743u32;
pub const PR_ORIGINAL_DISPLAY_TO: u32 = 7602206u32;
pub const PR_ORIGINAL_DISPLAY_TO_A: u32 = 7602206u32;
pub const PR_ORIGINAL_DISPLAY_TO_W: u32 = 7602207u32;
pub const PR_ORIGINAL_EITS: u32 = 2162946u32;
pub const PR_ORIGINAL_ENTRYID: u32 = 974258434u32;
pub const PR_ORIGINAL_SEARCH_KEY: u32 = 974389506u32;
pub const PR_ORIGINAL_SENDER_ADDRTYPE: u32 = 6684702u32;
pub const PR_ORIGINAL_SENDER_ADDRTYPE_A: u32 = 6684702u32;
pub const PR_ORIGINAL_SENDER_ADDRTYPE_W: u32 = 6684703u32;
pub const PR_ORIGINAL_SENDER_EMAIL_ADDRESS: u32 = 6750238u32;
pub const PR_ORIGINAL_SENDER_EMAIL_ADDRESS_A: u32 = 6750238u32;
pub const PR_ORIGINAL_SENDER_EMAIL_ADDRESS_W: u32 = 6750239u32;
pub const PR_ORIGINAL_SENDER_ENTRYID: u32 = 5964034u32;
pub const PR_ORIGINAL_SENDER_NAME: u32 = 5898270u32;
pub const PR_ORIGINAL_SENDER_NAME_A: u32 = 5898270u32;
pub const PR_ORIGINAL_SENDER_NAME_W: u32 = 5898271u32;
pub const PR_ORIGINAL_SENDER_SEARCH_KEY: u32 = 6029570u32;
pub const PR_ORIGINAL_SENDER_SID: u32 = 240058626u32;
pub const PR_ORIGINAL_SENDER_SID_AS_XML: u32 = 242221086u32;
pub const PR_ORIGINAL_SENSITIVITY: u32 = 3014659u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_ADDRTYPE: u32 = 6815774u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_ADDRTYPE_A: u32 = 6815774u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_ADDRTYPE_W: u32 = 6815775u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_EMAIL_ADDRESS: u32 = 6881310u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_EMAIL_ADDRESS_A: u32 = 6881310u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_EMAIL_ADDRESS_W: u32 = 6881311u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_ENTRYID: u32 = 6160642u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_NAME: u32 = 6094878u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_NAME_A: u32 = 6094878u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_NAME_W: u32 = 6094879u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_SEARCH_KEY: u32 = 6226178u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_SID: u32 = 240124162u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_SID_AS_XML: u32 = 242286622u32;
pub const PR_ORIGINAL_SUBJECT: u32 = 4784158u32;
pub const PR_ORIGINAL_SUBJECT_A: u32 = 4784158u32;
pub const PR_ORIGINAL_SUBJECT_W: u32 = 4784159u32;
pub const PR_ORIGINAL_SUBMIT_TIME: u32 = 5111872u32;
pub const PR_ORIGINATING_MTA_CERTIFICATE: u32 = 237306114u32;
pub const PR_ORIGINATOR_ADDR: u32 = 1717305374u32;
pub const PR_ORIGINATOR_ADDRTYPE: u32 = 1717370910u32;
pub const PR_ORIGINATOR_AND_DL_EXPANSION_HISTORY: u32 = 268566786u32;
pub const PR_ORIGINATOR_CERTIFICATE: u32 = 2228482u32;
pub const PR_ORIGINATOR_DELIVERY_REPORT_REQUESTED: u32 = 2293771u32;
pub const PR_ORIGINATOR_ENTRYID: u32 = 1717436674u32;
pub const PR_ORIGINATOR_NAME: u32 = 1717239838u32;
pub const PR_ORIGINATOR_NON_DELIVERY_REPORT_REQUESTED: u32 = 201850891u32;
pub const PR_ORIGINATOR_REQUESTED_ALTERNATE_RECIPIENT: u32 = 201916674u32;
pub const PR_ORIGINATOR_RETURN_ADDRESS: u32 = 2359554u32;
pub const PR_ORIGINATOR_SID: u32 = 240320770u32;
pub const PR_ORIGINATOR_SID_AS_XML: u32 = 242483230u32;
pub const PR_ORIGIN_CHECK: u32 = 2556162u32;
pub const PR_ORIGIN_ID: u32 = 1716322562u32;
pub const PR_ORIG_MESSAGE_CLASS: u32 = 4915230u32;
pub const PR_ORIG_MESSAGE_CLASS_A: u32 = 4915230u32;
pub const PR_ORIG_MESSAGE_CLASS_W: u32 = 4915231u32;
pub const PR_OST_ENCRYPTION: u32 = 1728184323u32;
pub const PR_OTHER_ADDRESS_CITY: u32 = 979304478u32;
pub const PR_OTHER_ADDRESS_CITY_A: u32 = 979304478u32;
pub const PR_OTHER_ADDRESS_CITY_W: u32 = 979304479u32;
pub const PR_OTHER_ADDRESS_COUNTRY: u32 = 979370014u32;
pub const PR_OTHER_ADDRESS_COUNTRY_A: u32 = 979370014u32;
pub const PR_OTHER_ADDRESS_COUNTRY_W: u32 = 979370015u32;
pub const PR_OTHER_ADDRESS_POSTAL_CODE: u32 = 979435550u32;
pub const PR_OTHER_ADDRESS_POSTAL_CODE_A: u32 = 979435550u32;
pub const PR_OTHER_ADDRESS_POSTAL_CODE_W: u32 = 979435551u32;
pub const PR_OTHER_ADDRESS_POST_OFFICE_BOX: u32 = 979632158u32;
pub const PR_OTHER_ADDRESS_POST_OFFICE_BOX_A: u32 = 979632158u32;
pub const PR_OTHER_ADDRESS_POST_OFFICE_BOX_W: u32 = 979632159u32;
pub const PR_OTHER_ADDRESS_STATE_OR_PROVINCE: u32 = 979501086u32;
pub const PR_OTHER_ADDRESS_STATE_OR_PROVINCE_A: u32 = 979501086u32;
pub const PR_OTHER_ADDRESS_STATE_OR_PROVINCE_W: u32 = 979501087u32;
pub const PR_OTHER_ADDRESS_STREET: u32 = 979566622u32;
pub const PR_OTHER_ADDRESS_STREET_A: u32 = 979566622u32;
pub const PR_OTHER_ADDRESS_STREET_W: u32 = 979566623u32;
pub const PR_OTHER_TELEPHONE_NUMBER: u32 = 975110174u32;
pub const PR_OTHER_TELEPHONE_NUMBER_A: u32 = 975110174u32;
pub const PR_OTHER_TELEPHONE_NUMBER_W: u32 = 975110175u32;
pub const PR_OUTBOUND_NEWSFEED_DN: u32 = 1720582174u32;
pub const PR_OVERALL_AGE_LIMIT: u32 = 1721303043u32;
pub const PR_OVERALL_MSG_AGE_LIMIT: u32 = 1720909827u32;
pub const PR_OWNER_APPT_ID: u32 = 6422531u32;
pub const PR_OWNER_COUNT: u32 = 1723203587u32;
pub const PR_OWN_STORE_ENTRYID: u32 = 1040580866u32;
pub const PR_P1_CONTENT: u32 = 285212930u32;
pub const PR_P1_CONTENT_TYPE: u32 = 285278466u32;
pub const PR_PAGER_TELEPHONE_NUMBER: u32 = 975241246u32;
pub const PR_PAGER_TELEPHONE_NUMBER_A: u32 = 975241246u32;
pub const PR_PAGER_TELEPHONE_NUMBER_W: u32 = 975241247u32;
pub const PR_PARENT_DISPLAY: u32 = 235208734u32;
pub const PR_PARENT_DISPLAY_A: u32 = 235208734u32;
pub const PR_PARENT_DISPLAY_W: u32 = 235208735u32;
pub const PR_PARENT_ENTRYID: u32 = 235471106u32;
pub const PR_PARENT_KEY: u32 = 2425090u32;
pub const PR_PARENT_SOURCE_KEY: u32 = 1709244674u32;
pub const PR_PARENT_URL_NAME: u32 = 1728905246u32;
pub const PR_PARENT_URL_NAME_A: u32 = 1728905246u32;
pub const PR_PARENT_URL_NAME_W: u32 = 1728905247u32;
pub const PR_PERSONAL_HOME_PAGE: u32 = 978321438u32;
pub const PR_PERSONAL_HOME_PAGE_A: u32 = 978321438u32;
pub const PR_PERSONAL_HOME_PAGE_W: u32 = 978321439u32;
pub const PR_PF_DISALLOW_MDB_WIDE_EXPIRY: u32 = 1730347019u32;
pub const PR_PF_MSG_SIZE_LIMIT: u32 = 1730281492u32;
pub const PR_PF_OVER_HARD_QUOTA_LIMIT: u32 = 1730215956u32;
pub const PR_PHYSICAL_DELIVERY_BUREAU_FAX_DELIVERY: u32 = 201981963u32;
pub const PR_PHYSICAL_DELIVERY_MODE: u32 = 202047491u32;
pub const PR_PHYSICAL_DELIVERY_REPORT_REQUEST: u32 = 202113027u32;
pub const PR_PHYSICAL_FORWARDING_ADDRESS: u32 = 202178818u32;
pub const PR_PHYSICAL_FORWARDING_ADDRESS_REQUESTED: u32 = 202244107u32;
pub const PR_PHYSICAL_FORWARDING_PROHIBITED: u32 = 202309643u32;
pub const PR_PHYSICAL_RENDITION_ATTRIBUTES: u32 = 202375426u32;
pub const PR_POLICY_TAG: u32 = 806945026u32;
pub const PR_POSTAL_ADDRESS: u32 = 974454814u32;
pub const PR_POSTAL_ADDRESS_A: u32 = 974454814u32;
pub const PR_POSTAL_ADDRESS_W: u32 = 974454815u32;
pub const PR_POSTAL_CODE: u32 = 975831070u32;
pub const PR_POSTAL_CODE_A: u32 = 975831070u32;
pub const PR_POSTAL_CODE_W: u32 = 975831071u32;
pub const PR_POST_OFFICE_BOX: u32 = 975896606u32;
pub const PR_POST_OFFICE_BOX_A: u32 = 975896606u32;
pub const PR_POST_OFFICE_BOX_W: u32 = 975896607u32;
pub const PR_PREDECESSOR_CHANGE_LIST: u32 = 1709375746u32;
pub const PR_PREFERRED_BY_NAME: u32 = 977731614u32;
pub const PR_PREFERRED_BY_NAME_A: u32 = 977731614u32;
pub const PR_PREFERRED_BY_NAME_W: u32 = 977731615u32;
pub const PR_PREPROCESS: u32 = 237109259u32;
pub const PR_PREVENT_MSG_CREATE: u32 = 1710489611u32;
pub const PR_PREVIEW: u32 = 1071185950u32;
pub const PR_PREVIEW_A: u32 = 1071185950u32;
pub const PR_PREVIEW_UNREAD: u32 = 1071120414u32;
pub const PR_PREVIEW_UNREAD_A: u32 = 1071120414u32;
pub const PR_PREVIEW_UNREAD_W: u32 = 1071120415u32;
pub const PR_PREVIEW_W: u32 = 1071185951u32;
pub const PR_PRIMARY_CAPABILITY: u32 = 956563714u32;
pub const PR_PRIMARY_FAX_NUMBER: u32 = 975372318u32;
pub const PR_PRIMARY_FAX_NUMBER_A: u32 = 975372318u32;
pub const PR_PRIMARY_FAX_NUMBER_W: u32 = 975372319u32;
pub const PR_PRIMARY_SEND_ACCT: u32 = 237502495u32;
pub const PR_PRIMARY_TELEPHONE_NUMBER: u32 = 974782494u32;
pub const PR_PRIMARY_TELEPHONE_NUMBER_A: u32 = 974782494u32;
pub const PR_PRIMARY_TELEPHONE_NUMBER_W: u32 = 974782495u32;
pub const PR_PRIORITY: u32 = 2490371u32;
pub const PR_PROFESSION: u32 = 977666078u32;
pub const PR_PROFESSION_A: u32 = 977666078u32;
pub const PR_PROFESSION_W: u32 = 977666079u32;
pub const PR_PROFILE_ABP_ALLOW_RECONNECT: u32 = 1715011587u32;
pub const PR_PROFILE_ABP_MTHREAD_TIMEOUT_SECS: u32 = 1715077123u32;
pub const PR_PROFILE_AB_FILES_PATH: u32 = 1712193566u32;
pub const PR_PROFILE_AB_FILES_PATH_W: u32 = 1712193567u32;
pub const PR_PROFILE_ADDR_INFO: u32 = 1720123650u32;
pub const PR_PROFILE_ALLPUB_COMMENT: u32 = 1712783390u32;
pub const PR_PROFILE_ALLPUB_COMMENT_W: u32 = 1712783391u32;
pub const PR_PROFILE_ALLPUB_DISPLAY_NAME: u32 = 1712717854u32;
pub const PR_PROFILE_ALLPUB_DISPLAY_NAME_W: u32 = 1712717855u32;
pub const PR_PROFILE_ALTERNATE_STORE_TYPE_W: u32 = 1708130335u32;
pub const PR_PROFILE_AUTH_PACKAGE: u32 = 1712914435u32;
pub const PR_PROFILE_BINDING_ORDER: u32 = 1711865886u32;
pub const PR_PROFILE_CONFIG_FLAGS: u32 = 1711341571u32;
pub const PR_PROFILE_CONNECT_FLAGS: u32 = 1711538179u32;
pub const PR_PROFILE_FAVFLD_COMMENT: u32 = 1712652318u32;
pub const PR_PROFILE_FAVFLD_COMMENT_W: u32 = 1712652319u32;
pub const PR_PROFILE_FAVFLD_DISPLAY_NAME: u32 = 1712259102u32;
pub const PR_PROFILE_FAVFLD_DISPLAY_NAME_W: u32 = 1712259103u32;
pub const PR_PROFILE_HOME_SERVER: u32 = 1711407134u32;
pub const PR_PROFILE_HOME_SERVER_ADDRS: u32 = 1712525342u32;
pub const PR_PROFILE_HOME_SERVER_DN: u32 = 1712455710u32;
pub const PR_PROFILE_MAILBOX: u32 = 1711996958u32;
pub const PR_PROFILE_MAX_RESTRICT: u32 = 1712128003u32;
pub const PR_PROFILE_MOAB: u32 = 1719336990u32;
pub const PR_PROFILE_MOAB_GUID: u32 = 1719402526u32;
pub const PR_PROFILE_MOAB_SEQ: u32 = 1719468035u32;
pub const PR_PROFILE_MOAB_W: u32 = 1719336991u32;
pub const PR_PROFILE_NAME: u32 = 1024589854u32;
pub const PR_PROFILE_NAME_A: u32 = 1024589854u32;
pub const PR_PROFILE_NAME_W: u32 = 1024589855u32;
pub const PR_PROFILE_OFFLINE_INFO: u32 = 1712390402u32;
pub const PR_PROFILE_OFFLINE_STORE_PATH: u32 = 1712324638u32;
pub const PR_PROFILE_OFFLINE_STORE_PATH_W: u32 = 1712324639u32;
pub const PR_PROFILE_OPEN_FLAGS: u32 = 1711865859u32;
pub const PR_PROFILE_OPTIONS_DATA: u32 = 1720254722u32;
pub const PR_PROFILE_RECONNECT_INTERVAL: u32 = 1712979971u32;
pub const PR_PROFILE_SECURE_MAILBOX: u32 = 1743782146u32;
pub const PR_PROFILE_SERVER: u32 = 1712062494u32;
pub const PR_PROFILE_SERVER_DN: u32 = 1712586782u32;
pub const PR_PROFILE_SERVER_FULL_VERSION: u32 = 1715142914u32;
pub const PR_PROFILE_SERVER_VERSION: u32 = 1713045507u32;
pub const PR_PROFILE_TRANSPORT_FLAGS: u32 = 1711603715u32;
pub const PR_PROFILE_TYPE: u32 = 1711931395u32;
pub const PR_PROFILE_UI_STATE: u32 = 1711669251u32;
pub const PR_PROFILE_UNRESOLVED_NAME: u32 = 1711734814u32;
pub const PR_PROFILE_UNRESOLVED_NAME_A: u32 = 1711734814u32;
pub const PR_PROFILE_UNRESOLVED_NAME_W: u32 = 1711734815u32;
pub const PR_PROFILE_UNRESOLVED_SERVER: u32 = 1711800350u32;
pub const PR_PROFILE_USER: u32 = 1711472670u32;
pub const PR_PROFILE_USER_SMTP_EMAIL_ADDRESS: u32 = 1715535902u32;
pub const PR_PROFILE_USER_SMTP_EMAIL_ADDRESS_A: u32 = 1715535902u32;
pub const PR_PROFILE_USER_SMTP_EMAIL_ADDRESS_W: u32 = 1715535903u32;
pub const PR_PROFILE_VERSION: u32 = 1711276035u32;
pub const PR_PROHIBIT_RECEIVE_QUOTA: u32 = 1718222851u32;
pub const PR_PROHIBIT_SEND_QUOTA: u32 = 1718484995u32;
pub const PR_PROMOTE_PROP_ID_LIST: u32 = 1718288642u32;
pub const PR_PROOF_OF_DELIVERY: u32 = 202440962u32;
pub const PR_PROOF_OF_DELIVERY_REQUESTED: u32 = 202506251u32;
pub const PR_PROOF_OF_SUBMISSION: u32 = 237371650u32;
pub const PR_PROOF_OF_SUBMISSION_REQUESTED: u32 = 2621451u32;
pub const PR_PROVIDER_DISPLAY: u32 = 805699614u32;
pub const PR_PROVIDER_DISPLAY_A: u32 = 805699614u32;
pub const PR_PROVIDER_DISPLAY_W: u32 = 805699615u32;
pub const PR_PROVIDER_DLL_NAME: u32 = 805961758u32;
pub const PR_PROVIDER_DLL_NAME_A: u32 = 805961758u32;
pub const PR_PROVIDER_DLL_NAME_W: u32 = 805961759u32;
pub const PR_PROVIDER_ORDINAL: u32 = 806158339u32;
pub const PR_PROVIDER_SUBMIT_TIME: u32 = 4718656u32;
pub const PR_PROVIDER_UID: u32 = 806093058u32;
pub const PR_PST_ENCRYPTION: u32 = 1728184323u32;
pub const PR_PST_PATH: u32 = 1728053278u32;
pub const PR_PST_PW_SZ_NEW: u32 = 1728315422u32;
pub const PR_PST_PW_SZ_OLD: u32 = 1728249886u32;
pub const PR_PST_REMEMBER_PW: u32 = 1728118795u32;
pub const PR_PUBLIC_FOLDER_ENTRYID: u32 = 1715208450u32;
pub const PR_PUBLISH_IN_ADDRESS_BOOK: u32 = 1072037899u32;
pub const PR_QUOTA_RECEIVE_THRESHOLD: u32 = 1730347011u32;
pub const PR_QUOTA_SEND_THRESHOLD: u32 = 1730281475u32;
pub const PR_QUOTA_WARNING_THRESHOLD: u32 = 1730215939u32;
pub const PR_RADIO_TELEPHONE_NUMBER: u32 = 974979102u32;
pub const PR_RADIO_TELEPHONE_NUMBER_A: u32 = 974979102u32;
pub const PR_RADIO_TELEPHONE_NUMBER_W: u32 = 974979103u32;
pub const PR_RANK: u32 = 1729232899u32;
pub const PR_RCVD_REPRESENTING_ADDRTYPE: u32 = 7798814u32;
pub const PR_RCVD_REPRESENTING_ADDRTYPE_A: u32 = 7798814u32;
pub const PR_RCVD_REPRESENTING_ADDRTYPE_W: u32 = 7798815u32;
pub const PR_RCVD_REPRESENTING_EMAIL_ADDRESS: u32 = 7864350u32;
pub const PR_RCVD_REPRESENTING_EMAIL_ADDRESS_A: u32 = 7864350u32;
pub const PR_RCVD_REPRESENTING_EMAIL_ADDRESS_W: u32 = 7864351u32;
pub const PR_RCVD_REPRESENTING_ENTRYID: u32 = 4391170u32;
pub const PR_RCVD_REPRESENTING_NAME: u32 = 4456478u32;
pub const PR_RCVD_REPRESENTING_NAME_A: u32 = 4456478u32;
pub const PR_RCVD_REPRESENTING_NAME_W: u32 = 4456479u32;
pub const PR_RCVD_REPRESENTING_SEARCH_KEY: u32 = 5374210u32;
pub const PR_RCVD_REPRESENTING_SID: u32 = 240582914u32;
pub const PR_RCVD_REPRESENTING_SID_AS_XML: u32 = 242745374u32;
pub const PR_RCVD_REPRESENTING_SMTP_ADDRESS: u32 = 1560805406u32;
pub const PR_RCVD_REPRESENTING_SMTP_ADDRESS_A: u32 = 1560805406u32;
pub const PR_RCVD_REPRESENTING_SMTP_ADDRESS_W: u32 = 1560805407u32;
pub const PR_READ: u32 = 241762315u32;
pub const PR_READ_RECEIPT_ENTRYID: u32 = 4587778u32;
pub const PR_READ_RECEIPT_REQUESTED: u32 = 2686987u32;
pub const PR_READ_RECEIPT_SEARCH_KEY: u32 = 5439746u32;
pub const PR_READ_RECEIPT_SID: u32 = 240189698u32;
pub const PR_READ_RECEIPT_SID_AS_XML: u32 = 242352158u32;
pub const PR_RECEIPT_TIME: u32 = 2752576u32;
pub const PR_RECEIVED_BY_ADDRTYPE: u32 = 7667742u32;
pub const PR_RECEIVED_BY_ADDRTYPE_A: u32 = 7667742u32;
pub const PR_RECEIVED_BY_ADDRTYPE_W: u32 = 7667743u32;
pub const PR_RECEIVED_BY_EMAIL_ADDRESS: u32 = 7733278u32;
pub const PR_RECEIVED_BY_EMAIL_ADDRESS_A: u32 = 7733278u32;
pub const PR_RECEIVED_BY_EMAIL_ADDRESS_W: u32 = 7733279u32;
pub const PR_RECEIVED_BY_ENTRYID: u32 = 4129026u32;
pub const PR_RECEIVED_BY_NAME: u32 = 4194334u32;
pub const PR_RECEIVED_BY_NAME_A: u32 = 4194334u32;
pub const PR_RECEIVED_BY_NAME_W: u32 = 4194335u32;
pub const PR_RECEIVED_BY_SEARCH_KEY: u32 = 5308674u32;
pub const PR_RECEIVED_BY_SID: u32 = 240517378u32;
pub const PR_RECEIVED_BY_SID_AS_XML: u32 = 242679838u32;
pub const PR_RECEIVED_BY_SMTP_ADDRESS: u32 = 1560739870u32;
pub const PR_RECEIVED_BY_SMTP_ADDRESS_A: u32 = 1560739870u32;
pub const PR_RECEIVED_BY_SMTP_ADDRESS_W: u32 = 1560739871u32;
pub const PR_RECEIVE_FOLDER_SETTINGS: u32 = 873791501u32;
pub const PR_RECIPIENT_CERTIFICATE: u32 = 202572034u32;
pub const PR_RECIPIENT_NUMBER: u32 = 1717698563u32;
pub const PR_RECIPIENT_NUMBER_FOR_ADVICE: u32 = 202637342u32;
pub const PR_RECIPIENT_NUMBER_FOR_ADVICE_A: u32 = 202637342u32;
pub const PR_RECIPIENT_NUMBER_FOR_ADVICE_W: u32 = 202637343u32;
pub const PR_RECIPIENT_ON_ASSOC_MSG_COUNT: u32 = 1722810371u32;
pub const PR_RECIPIENT_ON_NORMAL_MSG_COUNT: u32 = 1722744835u32;
pub const PR_RECIPIENT_REASSIGNMENT_PROHIBITED: u32 = 2818059u32;
pub const PR_RECIPIENT_STATUS: u32 = 236257283u32;
pub const PR_RECIPIENT_TYPE: u32 = 202702851u32;
pub const PR_RECORD_KEY: u32 = 267976962u32;
pub const PR_REDIRECTION_HISTORY: u32 = 2883842u32;
pub const PR_REGISTERED_MAIL_TYPE: u32 = 202768387u32;
pub const PR_RELATED_IPMS: u32 = 2949378u32;
pub const PR_REMOTE_PROGRESS: u32 = 1040908291u32;
pub const PR_REMOTE_PROGRESS_TEXT: u32 = 1040973854u32;
pub const PR_REMOTE_PROGRESS_TEXT_A: u32 = 1040973854u32;
pub const PR_REMOTE_PROGRESS_TEXT_W: u32 = 1040973855u32;
pub const PR_REMOTE_VALIDATE_OK: u32 = 1041039371u32;
pub const PR_RENDERING_POSITION: u32 = 923467779u32;
pub const PR_REPLICATION_ALWAYS_INTERVAL: u32 = 1720975363u32;
pub const PR_REPLICATION_MESSAGE_PRIORITY: u32 = 1720844291u32;
pub const PR_REPLICATION_MSG_SIZE: u32 = 1721040899u32;
pub const PR_REPLICATION_SCHEDULE: u32 = 1720779010u32;
pub const PR_REPLICATION_STYLE: u32 = 1720713219u32;
pub const PR_REPLICA_LIST: u32 = 1721237762u32;
pub const PR_REPLICA_SERVER: u32 = 1715732510u32;
pub const PR_REPLICA_SERVER_W: u32 = 1715732511u32;
pub const PR_REPLICA_VERSION: u32 = 1716191252u32;
pub const PR_REPLY_RECIPIENT_ENTRIES: u32 = 5177602u32;
pub const PR_REPLY_RECIPIENT_NAMES: u32 = 5242910u32;
pub const PR_REPLY_RECIPIENT_NAMES_A: u32 = 5242910u32;
pub const PR_REPLY_RECIPIENT_NAMES_W: u32 = 5242911u32;
pub const PR_REPLY_RECIPIENT_SMTP_PROXIES: u32 = 1073479710u32;
pub const PR_REPLY_REQUESTED: u32 = 202833931u32;
pub const PR_REPLY_TIME: u32 = 3145792u32;
pub const PR_REPORTING_DL_NAME: u32 = 268632322u32;
pub const PR_REPORTING_MTA_CERTIFICATE: u32 = 268697858u32;
pub const PR_REPORT_DESTINATION_ENTRYID: u32 = 1717895426u32;
pub const PR_REPORT_DESTINATION_NAME: u32 = 1717829662u32;
pub const PR_REPORT_DESTINATION_SID: u32 = 240386306u32;
pub const PR_REPORT_DESTINATION_SID_AS_XML: u32 = 242548766u32;
pub const PR_REPORT_ENTRYID: u32 = 4522242u32;
pub const PR_REPORT_NAME: u32 = 3801118u32;
pub const PR_REPORT_NAME_A: u32 = 3801118u32;
pub const PR_REPORT_NAME_W: u32 = 3801119u32;
pub const PR_REPORT_SEARCH_KEY: u32 = 5505282u32;
pub const PR_REPORT_SID: u32 = 240255234u32;
pub const PR_REPORT_SID_AS_XML: u32 = 242417694u32;
pub const PR_REPORT_TAG: u32 = 3211522u32;
pub const PR_REPORT_TEXT: u32 = 268501022u32;
pub const PR_REPORT_TEXT_A: u32 = 268501022u32;
pub const PR_REPORT_TEXT_W: u32 = 268501023u32;
pub const PR_REPORT_TIME: u32 = 3276864u32;
pub const PR_REQUESTED_DELIVERY_METHOD: u32 = 202899459u32;
pub const PR_RESERVE_RANGE_OF_IDS: u32 = 242942210u32;
pub const PR_RESOLVE_METHOD: u32 = 1072103427u32;
pub const PR_RESOURCE_FLAGS: u32 = 805896195u32;
pub const PR_RESOURCE_METHODS: u32 = 1040318467u32;
pub const PR_RESOURCE_PATH: u32 = 1040646174u32;
pub const PR_RESOURCE_PATH_A: u32 = 1040646174u32;
pub const PR_RESOURCE_PATH_W: u32 = 1040646175u32;
pub const PR_RESOURCE_TYPE: u32 = 1040384003u32;
pub const PR_RESPONSE_REQUESTED: u32 = 6488075u32;
pub const PR_RESPONSIBILITY: u32 = 235864075u32;
pub const PR_RESTRICTION_COUNT: u32 = 1722417155u32;
pub const PR_RETENTION_AGE_LIMIT: u32 = 1724121091u32;
pub const PR_RETENTION_DATE: u32 = 807141440u32;
pub const PR_RETENTION_FLAGS: u32 = 807206915u32;
pub const PR_RETENTION_PERIOD: u32 = 807010307u32;
pub const PR_RETURNED_IPM: u32 = 3342347u32;
pub const PR_RIGHTS: u32 = 1715011587u32;
pub const PR_ROH_FLAGS: u32 = 1713569795u32;
pub const PR_ROH_PROXY_AUTH_SCHEME: u32 = 1713831939u32;
pub const PR_ROWID: u32 = 805306371u32;
pub const PR_ROW_TYPE: u32 = 267714563u32;
pub const PR_RTF_COMPRESSED: u32 = 269025538u32;
pub const PR_RTF_IN_SYNC: u32 = 236912651u32;
pub const PR_RTF_SYNC_BODY_COUNT: u32 = 268894211u32;
pub const PR_RTF_SYNC_BODY_CRC: u32 = 268828675u32;
pub const PR_RTF_SYNC_BODY_TAG: u32 = 268959774u32;
pub const PR_RTF_SYNC_BODY_TAG_A: u32 = 268959774u32;
pub const PR_RTF_SYNC_BODY_TAG_W: u32 = 268959775u32;
pub const PR_RTF_SYNC_PREFIX_COUNT: u32 = 269484035u32;
pub const PR_RTF_SYNC_TRAILING_COUNT: u32 = 269549571u32;
pub const PR_RULES_DATA: u32 = 1071710466u32;
pub const PR_RULES_TABLE: u32 = 1071710221u32;
pub const PR_RULE_ACTIONS: u32 = 1719664894u32;
pub const PR_RULE_ACTION_NUMBER: u32 = 1716518915u32;
pub const PR_RULE_ACTION_TYPE: u32 = 1716060163u32;
pub const PR_RULE_CONDITION: u32 = 1719206141u32;
pub const PR_RULE_ERROR: u32 = 1715994627u32;
pub const PR_RULE_FOLDER_ENTRYID: u32 = 1716584706u32;
pub const PR_RULE_ID: u32 = 1718878228u32;
pub const PR_RULE_IDS: u32 = 1718944002u32;
pub const PR_RULE_LEVEL: u32 = 1719861251u32;
pub const PR_RULE_MSG_LEVEL: u32 = 1710030851u32;
pub const PR_RULE_MSG_NAME_W: u32 = 1709965343u32;
pub const PR_RULE_MSG_PROVIDER_DATA: u32 = 1710096642u32;
pub const PR_RULE_MSG_PROVIDER_W: u32 = 1709899807u32;
pub const PR_RULE_MSG_SEQUENCE: u32 = 1710424067u32;
pub const PR_RULE_MSG_STATE: u32 = 1709768707u32;
pub const PR_RULE_MSG_USER_FLAGS: u32 = 1709834243u32;
pub const PR_RULE_NAME: u32 = 1719795742u32;
pub const PR_RULE_PROVIDER: u32 = 1719730206u32;
pub const PR_RULE_PROVIDER_DATA: u32 = 1719927042u32;
pub const PR_RULE_SEQUENCE: u32 = 1719009283u32;
pub const PR_RULE_SERVER_RULE_ID: u32 = 1704984596u32;
pub const PR_RULE_STATE: u32 = 1719074819u32;
pub const PR_RULE_TRIGGER_HISTORY: u32 = 1072824578u32;
pub const PR_RULE_USER_FLAGS: u32 = 1719140355u32;
pub const PR_SCHEDULE_FOLDER_ENTRYID: u32 = 1713242370u32;
pub const PR_SEARCH: u32 = 906428429u32;
pub const PR_SEARCH_KEY: u32 = 806027522u32;
pub const PR_SECURE_IN_SITE: u32 = 1721630731u32;
pub const PR_SECURE_ORIGINATION: u32 = 1071972363u32;
pub const PR_SECURITY: u32 = 3407875u32;
pub const PR_SELECTABLE: u32 = 906559499u32;
pub const PR_SENDER_ADDRTYPE: u32 = 203292702u32;
pub const PR_SENDER_ADDRTYPE_A: u32 = 203292702u32;
pub const PR_SENDER_ADDRTYPE_W: u32 = 203292703u32;
pub const PR_SENDER_EMAIL_ADDRESS: u32 = 203358238u32;
pub const PR_SENDER_EMAIL_ADDRESS_A: u32 = 203358238u32;
pub const PR_SENDER_EMAIL_ADDRESS_W: u32 = 203358239u32;
pub const PR_SENDER_ENTRYID: u32 = 202965250u32;
pub const PR_SENDER_NAME: u32 = 203030558u32;
pub const PR_SENDER_NAME_A: u32 = 203030558u32;
pub const PR_SENDER_NAME_W: u32 = 203030559u32;
pub const PR_SENDER_SEARCH_KEY: u32 = 203227394u32;
pub const PR_SENDER_SID: u32 = 239927554u32;
pub const PR_SENDER_SID_AS_XML: u32 = 242090014u32;
pub const PR_SENDER_SMTP_ADDRESS: u32 = 1560346654u32;
pub const PR_SENDER_SMTP_ADDRESS_A: u32 = 1560346654u32;
pub const PR_SENDER_SMTP_ADDRESS_W: u32 = 1560346655u32;
pub const PR_SEND_RICH_INFO: u32 = 977272843u32;
pub const PR_SENSITIVITY: u32 = 3538947u32;
pub const PR_SENTMAIL_ENTRYID: u32 = 235536642u32;
pub const PR_SENT_REPRESENTING_ADDRTYPE: u32 = 6553630u32;
pub const PR_SENT_REPRESENTING_ADDRTYPE_A: u32 = 6553630u32;
pub const PR_SENT_REPRESENTING_ADDRTYPE_W: u32 = 6553631u32;
pub const PR_SENT_REPRESENTING_EMAIL_ADDRESS: u32 = 6619166u32;
pub const PR_SENT_REPRESENTING_EMAIL_ADDRESS_A: u32 = 6619166u32;
pub const PR_SENT_REPRESENTING_EMAIL_ADDRESS_W: u32 = 6619167u32;
pub const PR_SENT_REPRESENTING_ENTRYID: u32 = 4260098u32;
pub const PR_SENT_REPRESENTING_NAME: u32 = 4325406u32;
pub const PR_SENT_REPRESENTING_NAME_A: u32 = 4325406u32;
pub const PR_SENT_REPRESENTING_NAME_W: u32 = 4325407u32;
pub const PR_SENT_REPRESENTING_SEARCH_KEY: u32 = 3866882u32;
pub const PR_SENT_REPRESENTING_SID: u32 = 239993090u32;
pub const PR_SENT_REPRESENTING_SID_AS_XML: u32 = 242155550u32;
pub const PR_SENT_REPRESENTING_SMTP_ADDRESS: u32 = 1560412190u32;
pub const PR_SENT_REPRESENTING_SMTP_ADDRESS_A: u32 = 1560412190u32;
pub const PR_SENT_REPRESENTING_SMTP_ADDRESS_W: u32 = 1560412191u32;
pub const PR_SERVICES: u32 = 1024327938u32;
pub const PR_SERVICE_DELETE_FILES: u32 = 1024462878u32;
pub const PR_SERVICE_DELETE_FILES_A: u32 = 1024462878u32;
pub const PR_SERVICE_DELETE_FILES_W: u32 = 1024462879u32;
pub const PR_SERVICE_DLL_NAME: u32 = 1024065566u32;
pub const PR_SERVICE_DLL_NAME_A: u32 = 1024065566u32;
pub const PR_SERVICE_DLL_NAME_W: u32 = 1024065567u32;
pub const PR_SERVICE_ENTRY_NAME: u32 = 1024131102u32;
pub const PR_SERVICE_EXTRA_UIDS: u32 = 1024262402u32;
pub const PR_SERVICE_NAME: u32 = 1024000030u32;
pub const PR_SERVICE_NAME_A: u32 = 1024000030u32;
pub const PR_SERVICE_NAME_W: u32 = 1024000031u32;
pub const PR_SERVICE_SUPPORT_FILES: u32 = 1024397342u32;
pub const PR_SERVICE_SUPPORT_FILES_A: u32 = 1024397342u32;
pub const PR_SERVICE_SUPPORT_FILES_W: u32 = 1024397343u32;
pub const PR_SERVICE_UID: u32 = 1024196866u32;
pub const PR_SHORTTERM_ENTRYID_FROM_OBJECT: u32 = 1718747394u32;
pub const PR_SHORTTERM_PARENT_ENTRYID_FROM_OBJECT: u32 = 1718681858u32;
pub const PR_SMTP_ADDRESS: u32 = 972947486u32;
pub const PR_SMTP_ADDRESS_A: u32 = 972947486u32;
pub const PR_SMTP_ADDRESS_W: u32 = 972947487u32;
pub const PR_SORT_LOCALE_ID: u32 = 1728380931u32;
pub const PR_SORT_PARENTID: u32 = 807469314u32;
pub const PR_SORT_POSITION: u32 = 807403778u32;
pub const PR_SOURCE_FID: u32 = 241106964u32;
pub const PR_SOURCE_KEY: u32 = 1709179138u32;
pub const PR_SPLUS_FREE_BUSY_ENTRYID: u32 = 1713504514u32;
pub const PR_SPOOLER_STATUS: u32 = 235929603u32;
pub const PR_SPOUSE_NAME: u32 = 977797150u32;
pub const PR_SPOUSE_NAME_A: u32 = 977797150u32;
pub const PR_SPOUSE_NAME_W: u32 = 977797151u32;
pub const PR_SRC_URL_NAME: u32 = 1729036318u32;
pub const PR_SRC_URL_NAME_A: u32 = 1729036318u32;
pub const PR_SRC_URL_NAME_W: u32 = 1729036319u32;
pub const PR_START_DATE: u32 = 6291520u32;
pub const PR_START_DATE_ETC: u32 = 807076098u32;
pub const PR_STATE_OR_PROVINCE: u32 = 975699998u32;
pub const PR_STATE_OR_PROVINCE_A: u32 = 975699998u32;
pub const PR_STATE_OR_PROVINCE_W: u32 = 975699999u32;
pub const PR_STATUS: u32 = 906690563u32;
pub const PR_STATUS_CODE: u32 = 1040449539u32;
pub const PR_STATUS_STRING: u32 = 1040711710u32;
pub const PR_STATUS_STRING_A: u32 = 1040711710u32;
pub const PR_STATUS_STRING_W: u32 = 1040711711u32;
pub const PR_STORAGE_LIMIT_INFORMATION: u32 = 1722023939u32;
pub const PR_STORAGE_QUOTA_LIMIT: u32 = 1073020931u32;
pub const PR_STORE_ENTRYID: u32 = 268108034u32;
pub const PR_STORE_OFFLINE: u32 = 1714552843u32;
pub const PR_STORE_PROVIDERS: u32 = 1023410434u32;
pub const PR_STORE_RECORD_KEY: u32 = 268042498u32;
pub const PR_STORE_SLOWLINK: u32 = 2081030155u32;
pub const PR_STORE_STATE: u32 = 873332739u32;
pub const PR_STORE_SUPPORT_MASK: u32 = 873267203u32;
pub const PR_STREET_ADDRESS: u32 = 975765534u32;
pub const PR_STREET_ADDRESS_A: u32 = 975765534u32;
pub const PR_STREET_ADDRESS_W: u32 = 975765535u32;
pub const PR_SUBFOLDER: u32 = 1728577547u32;
pub const PR_SUBFOLDERS: u32 = 906625035u32;
pub const PR_SUBJECT: u32 = 3604510u32;
pub const PR_SUBJECT_A: u32 = 3604510u32;
pub const PR_SUBJECT_IPM: u32 = 3670274u32;
pub const PR_SUBJECT_PREFIX: u32 = 3997726u32;
pub const PR_SUBJECT_PREFIX_A: u32 = 3997726u32;
pub const PR_SUBJECT_PREFIX_W: u32 = 3997727u32;
pub const PR_SUBJECT_TRACE_INFO: u32 = 1717633282u32;
pub const PR_SUBJECT_W: u32 = 3604511u32;
pub const PR_SUBMIT_FLAGS: u32 = 236191747u32;
pub const PR_SUPPLEMENTARY_INFO: u32 = 203096094u32;
pub const PR_SUPPLEMENTARY_INFO_A: u32 = 203096094u32;
pub const PR_SUPPLEMENTARY_INFO_W: u32 = 203096095u32;
pub const PR_SURNAME: u32 = 974192670u32;
pub const PR_SURNAME_A: u32 = 974192670u32;
pub const PR_SURNAME_W: u32 = 974192671u32;
pub const PR_SVR_GENERATING_QUOTA_MSG: u32 = 1073152030u32;
pub const PR_SYNCEVENT_FIRED: u32 = 1716453387u32;
pub const PR_SYNCEVENT_SUPPRESS_GUID: u32 = 947912962u32;
pub const PR_SYNCHRONIZE_FLAGS: u32 = 1709441027u32;
pub const PR_SYS_CONFIG_FOLDER_ENTRYID: u32 = 1714815234u32;
pub const PR_TELEX_NUMBER: u32 = 975962142u32;
pub const PR_TELEX_NUMBER_A: u32 = 975962142u32;
pub const PR_TELEX_NUMBER_W: u32 = 975962143u32;
pub const PR_TEMPLATEID: u32 = 956432642u32;
pub const PR_TEST_LINE_SPEED: u32 = 1714094338u32;
pub const PR_TITLE: u32 = 974585886u32;
pub const PR_TITLE_A: u32 = 974585886u32;
pub const PR_TITLE_W: u32 = 974585887u32;
pub const PR_TNEF_CORRELATION_KEY: u32 = 8323330u32;
pub const PR_TNEF_UNPROCESSED_PROPS: u32 = 245104898u32;
pub const PR_TRACE_INFO: u32 = 1717567746u32;
pub const PR_TRANSFER_ENABLED: u32 = 1714028555u32;
pub const PR_TRANSMITABLE_DISPLAY_NAME: u32 = 975175710u32;
pub const PR_TRANSMITABLE_DISPLAY_NAME_A: u32 = 975175710u32;
pub const PR_TRANSMITABLE_DISPLAY_NAME_W: u32 = 975175711u32;
pub const PR_TRANSPORT_KEY: u32 = 236322819u32;
pub const PR_TRANSPORT_MESSAGE_HEADERS: u32 = 8192030u32;
pub const PR_TRANSPORT_MESSAGE_HEADERS_A: u32 = 8192030u32;
pub const PR_TRANSPORT_MESSAGE_HEADERS_W: u32 = 8192031u32;
pub const PR_TRANSPORT_PROVIDERS: u32 = 1023541506u32;
pub const PR_TRANSPORT_STATUS: u32 = 235995139u32;
pub const PR_TRUST_SENDER: u32 = 242810883u32;
pub const PR_TRUST_SENDER_NO: i32 = 0i32;
pub const PR_TRUST_SENDER_YES: i32 = 1i32;
pub const PR_TTYTDD_PHONE_NUMBER: u32 = 977993758u32;
pub const PR_TTYTDD_PHONE_NUMBER_A: u32 = 977993758u32;
pub const PR_TTYTDD_PHONE_NUMBER_W: u32 = 977993759u32;
pub const PR_TYPE_OF_MTS_USER: u32 = 203161603u32;
pub const PR_URL_COMP_NAME: u32 = 284360734u32;
pub const PR_URL_COMP_NAME_A: u32 = 284360734u32;
pub const PR_URL_COMP_NAME_W: u32 = 284360735u32;
pub const PR_URL_NAME: u32 = 1728512030u32;
pub const PR_URL_NAME_A: u32 = 1728512030u32;
pub const PR_URL_NAME_W: u32 = 1728512031u32;
pub const PR_USER_CERTIFICATE: u32 = 975307010u32;
pub const PR_USER_ENTRYID: u32 = 1712914690u32;
pub const PR_USER_NAME: u32 = 1712979998u32;
pub const PR_VALID_FOLDER_MASK: u32 = 903806979u32;
pub const PR_VIEWS_ENTRYID: u32 = 904200450u32;
pub const PR_WEDDING_ANNIVERSARY: u32 = 977338432u32;
pub const PR_WIN32_SECURITY_DESCRIPTOR: u32 = 1025638658u32;
pub const PR_WIZARD_NO_PAB_PAGE: u32 = 1728118795u32;
pub const PR_WIZARD_NO_PST_PAGE: u32 = 1728053259u32;
pub const PR_X400_CONTENT_TYPE: u32 = 3932418u32;
pub const PR_X400_DEFERRED_DELIVERY_CANCEL: u32 = 1040777227u32;
pub const PR_X400_ENVELOPE_TYPE: u32 = 1716715523u32;
pub const PR_XMT_SECURITY_ROLE_1: u32 = 1025835266u32;
pub const PR_XMT_SECURITY_ROLE_1_AS_XML: u32 = 1025835038u32;
pub const PR_XMT_SECURITY_ROLE_2: u32 = 1025900802u32;
pub const PR_XMT_SECURITY_ROLE_2_AS_XML: u32 = 1025900574u32;
pub const PR_XMT_SECURITY_ROLE_3: u32 = 1025966338u32;
pub const PR_XMT_SECURITY_ROLE_3_AS_XML: u32 = 1025966110u32;
pub const PR_XMT_SECURITY_ROLE_4: u32 = 1026031874u32;
pub const PR_XMT_SECURITY_ROLE_4_AS_XML: u32 = 1026031646u32;
pub const PR_XMT_SECURITY_ROLE_5: u32 = 1026097410u32;
pub const PR_XMT_SECURITY_ROLE_5_AS_XML: u32 = 1026097182u32;
pub const PR_XMT_SECURITY_ROLE_6: u32 = 1026162946u32;
pub const PR_XMT_SECURITY_ROLE_6_AS_XML: u32 = 1026162718u32;
pub const PR_XMT_SECURITY_ROLE_7: u32 = 1026228482u32;
pub const PR_XMT_SECURITY_ROLE_7_AS_XML: u32 = 1026228254u32;
pub const PR_XMT_SECURITY_ROLE_8: u32 = 1026294018u32;
pub const PR_XMT_SECURITY_ROLE_8_AS_XML: u32 = 1026293790u32;
pub const PR_XPOS: u32 = 1057292291u32;
pub const PR_YPOS: u32 = 1057357827u32;
pub const PSETID_Address: windows_core::GUID =
    windows_core::GUID::from_u128(0x00062004_0000_0000_c000_000000000046);
pub const PSETID_Appointment: windows_core::GUID =
    windows_core::GUID::from_u128(0x00062002_0000_0000_c000_000000000046);
pub const PSETID_Attachment: windows_core::GUID =
    windows_core::GUID::from_u128(0x96357f7f_59e1_47d0_99a7_46515c183b54);
pub const PSETID_Common: windows_core::GUID =
    windows_core::GUID::from_u128(0x00062008_0000_0000_c000_000000000046);
pub const PSETID_Log: windows_core::GUID =
    windows_core::GUID::from_u128(0x0006200a_0000_0000_c000_000000000046);
pub const PSETID_Meeting: windows_core::GUID =
    windows_core::GUID::from_u128(0x6ed8da90_450b_101b_98da_00aa003f1305);
pub const PSETID_Messaging: windows_core::GUID =
    windows_core::GUID::from_u128(0x41f28f13_83f4_4114_a584_eedb5a6b0bff);
pub const PSETID_Note: windows_core::GUID =
    windows_core::GUID::from_u128(0x0006200e_0000_0000_c000_000000000046);
pub const PSETID_PostRss: windows_core::GUID =
    windows_core::GUID::from_u128(0x00062041_0000_0000_c000_000000000046);
pub const PSETID_Remote: windows_core::GUID =
    windows_core::GUID::from_u128(0x00062014_0000_0000_c000_000000000046);
pub const PSETID_Report: windows_core::GUID =
    windows_core::GUID::from_u128(0x00062013_0000_0000_c000_000000000046);
pub const PSETID_Sharing: windows_core::GUID =
    windows_core::GUID::from_u128(0x00062040_0000_0000_c000_000000000046);
pub const PSETID_Task: windows_core::GUID =
    windows_core::GUID::from_u128(0x00062003_0000_0000_c000_000000000046);
pub const PSETID_UnifiedMessaging: windows_core::GUID =
    windows_core::GUID::from_u128(0x4442858e_a9e3_4e80_b900_317a210cc15b);
pub const PSETID_XmlExtractedEntities: windows_core::GUID =
    windows_core::GUID::from_u128(0x23239608_685d_4732_9c55_4c95cb4e8e33);
pub const PSTF_BEST_ENCRYPTION: u32 = 536870912u32;
pub const PSTF_COMPRESSABLE_ENCRYPTION: u32 = 1073741824u32;
pub const PSTF_NO_ENCRYPTION: u32 = 2147483648u32;
pub const PST_EXTERN_PROPID_BASE: u32 = 26368u32;
pub const PS_INTERNET_HEADERS: windows_core::GUID =
    windows_core::GUID::from_u128(0x00020386_0000_0000_c000_000000000046);
pub const PS_MAPI: windows_core::GUID =
    windows_core::GUID::from_u128(0x00020328_0000_0000_c000_000000000046);
pub const PS_PUBLIC_STRINGS: windows_core::GUID =
    windows_core::GUID::from_u128(0x00020329_0000_0000_c000_000000000046);
pub const PS_ROUTING_ADDRTYPE: windows_core::GUID =
    windows_core::GUID::from_u128(0x00020381_0000_0000_c000_000000000046);
pub const PS_ROUTING_DISPLAY_NAME: windows_core::GUID =
    windows_core::GUID::from_u128(0x00020382_0000_0000_c000_000000000046);
pub const PS_ROUTING_EMAIL_ADDRESSES: windows_core::GUID =
    windows_core::GUID::from_u128(0x00020380_0000_0000_c000_000000000046);
pub const PS_ROUTING_ENTRYID: windows_core::GUID =
    windows_core::GUID::from_u128(0x00020383_0000_0000_c000_000000000046);
pub const PS_ROUTING_SEARCH_KEY: windows_core::GUID =
    windows_core::GUID::from_u128(0x00020384_0000_0000_c000_000000000046);
pub const PT_ACTIONS: u32 = 254u32;
pub const PT_APPTIME: u32 = 7u32;
pub const PT_BINARY: u32 = 258u32;
pub const PT_BOOLEAN: u32 = 11u32;
pub const PT_CLSID: u32 = 72u32;
pub const PT_CURRENCY: u32 = 6u32;
pub const PT_DOUBLE: u32 = 5u32;
pub const PT_ERROR: u32 = 10u32;
pub const PT_FILE_EA: u32 = 260u32;
pub const PT_FILE_HANDLE: u32 = 259u32;
pub const PT_FLOAT: u32 = 4u32;
pub const PT_I2: u32 = 2u32;
pub const PT_I4: u32 = 3u32;
pub const PT_I8: u32 = 20u32;
pub const PT_LONG: u32 = 3u32;
pub const PT_LONGLONG: u32 = 20u32;
pub const PT_MV_APPTIME: u32 = 4103u32;
pub const PT_MV_BINARY: u32 = 4354u32;
pub const PT_MV_CLSID: u32 = 4168u32;
pub const PT_MV_CURRENCY: u32 = 4102u32;
pub const PT_MV_DOUBLE: u32 = 4101u32;
pub const PT_MV_FLOAT: u32 = 4100u32;
pub const PT_MV_I2: u32 = 4098u32;
pub const PT_MV_I4: u32 = 4099u32;
pub const PT_MV_I8: u32 = 4116u32;
pub const PT_MV_LONG: u32 = 4099u32;
pub const PT_MV_LONGLONG: u32 = 4116u32;
pub const PT_MV_R4: u32 = 4100u32;
pub const PT_MV_R8: u32 = 4101u32;
pub const PT_MV_SHORT: u32 = 4098u32;
pub const PT_MV_STRING8: u32 = 4126u32;
pub const PT_MV_SYSTIME: u32 = 4160u32;
pub const PT_MV_TSTRING: u32 = 4126u32;
pub const PT_MV_UNICODE: u32 = 4127u32;
pub const PT_NULL: u32 = 1u32;
pub const PT_OBJECT: u32 = 13u32;
pub const PT_PTR: u32 = 259u32;
pub const PT_R4: u32 = 4u32;
pub const PT_R8: u32 = 5u32;
pub const PT_SHORT: u32 = 2u32;
pub const PT_SRESTRICTION: u32 = 253u32;
pub const PT_STRING8: u32 = 30u32;
pub const PT_SYSTIME: u32 = 64u32;
pub const PT_TSTRING: u32 = 31u32;
pub const PT_UNICODE: u32 = 31u32;
pub const PT_UNSPECIFIED: u32 = 0u32;
pub const PT_VIRTUAL: u32 = 261u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct READSTATE {
    pub cbSourceKey: u32,
    pub pbSourceKey: *mut u8,
    pub ulFlags: u32,
}
impl Default for READSTATE {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const RECURSIVE_SEARCH: u32 = 4u32;
pub const RECURSIVE_SORT: u32 = 2u32;
pub const REFRESH_XP_HEADER_CACHE: u32 = 65536u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct RELOADTYPE(pub i32);
pub const RELOAD_HEADER_APPEND: RELOADTYPE = RELOADTYPE(2i32);
pub const RELOAD_HEADER_NONE: RELOADTYPE = RELOADTYPE(0i32);
pub const RELOAD_HEADER_REPLACE: RELOADTYPE = RELOADTYPE(3i32);
pub const RELOAD_HEADER_RESET: RELOADTYPE = RELOADTYPE(1i32);
pub const RELOP_EQ: u32 = 4u32;
pub const RELOP_GE: u32 = 3u32;
pub const RELOP_GT: u32 = 2u32;
pub const RELOP_LE: u32 = 1u32;
pub const RELOP_LT: u32 = 0u32;
pub const RELOP_MEMBER_OF_DL: u32 = 100u32;
pub const RELOP_NE: u32 = 5u32;
pub const RELOP_RE: u32 = 6u32;
pub type REMOVEPREPROCESSINFO = Option<
    unsafe extern "system" fn(lpmessage: windows_core::Ref<'_, IMessage>) -> windows_core::HRESULT,
>;
pub const RESOLVE_METHOD_DEFAULT: u32 = 0u32;
pub const RESOLVE_METHOD_LAST_WRITER_WINS: u32 = 1u32;
pub const RESOLVE_METHOD_NO_CONFLICT_NOTIFICATION: u32 = 2u32;
pub const RESTART_SEARCH: u32 = 2u32;
pub const RES_AND: u32 = 0u32;
pub const RES_ANNOTATION: u32 = 12u32;
pub const RES_BITMASK: u32 = 6u32;
pub const RES_COMMENT: u32 = 10u32;
pub const RES_COMPAREPROPS: u32 = 5u32;
pub const RES_CONTENT: u32 = 3u32;
pub const RES_COUNT: u32 = 11u32;
pub const RES_EXIST: u32 = 8u32;
pub const RES_NOT: u32 = 2u32;
pub const RES_OR: u32 = 1u32;
pub const RES_PROPERTY: u32 = 4u32;
pub const RES_SIZE: u32 = 7u32;
pub const RES_SUBRESTRICTION: u32 = 9u32;
pub const RETENTION_FLAGS_AUTOTAG: u32 = 4u32;
pub const RETENTION_FLAGS_EXPLICIT: u32 = 1u32;
pub const RETENTION_FLAGS_EXPLICIT_ARCHIVE: u32 = 16u32;
pub const RETENTION_FLAGS_PERSONAL: u32 = 8u32;
pub const RETENTION_FLAGS_TAG_CHANGED: u32 = 2u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct RFC1522INFO {
    pub fRfc1522Allowed: windows_core::BOOL,
    pub fRfc1522Used: windows_core::BOOL,
    pub fAllow8bit: windows_core::BOOL,
    pub hRfc1522Cset: *mut HCHARSET__,
}
impl Default for RFC1522INFO {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const ROHAUTH_BASIC: u32 = 1u32;
pub const ROHAUTH_NTLM: u32 = 2u32;
pub const ROHFLAGS_HTTP_FIRST_ON_FAST: u32 = 8u32;
pub const ROHFLAGS_HTTP_FIRST_ON_SLOW: u32 = 32u32;
pub const ROHFLAGS_MUTUAL_AUTH: u32 = 4u32;
pub const ROHFLAGS_SSL_ONLY: u32 = 2u32;
pub const ROHFLAGS_USE_ROH: u32 = 1u32;
pub const ROLESCOPE_FOLDER: u32 = 1u32;
pub const ROLESCOPE_MAX: u32 = 1u32;
pub const ROLESCOPE_OBJECT: u32 = 0u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ROWENTRY {
    pub ulRowFlags: u32,
    pub cValues: u32,
    pub rgPropVals: *mut SPropValue,
}
impl Default for ROWENTRY {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ROWLIST {
    pub cEntries: u32,
    pub aEntries: [ROWENTRY; 1],
}
impl Default for ROWLIST {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const ROWLIST_REPLACE: u32 = 1u32;
pub const ROW_ADD: u32 = 1u32;
pub const ROW_MODIFY: u32 = 2u32;
pub const ROW_REMOVE: u32 = 4u32;
pub const RTF_SYNC_BODY_CHANGED: u32 = 2u32;
pub const RTF_SYNC_RTF_CHANGED: u32 = 1u32;
pub const RULE_ERR_CREATE_DAE: u32 = 5u32;
pub const RULE_ERR_CREATE_DAM: u32 = 8u32;
pub const RULE_ERR_DELIVERY: u32 = 3u32;
pub const RULE_ERR_EXECUTION: u32 = 11u32;
pub const RULE_ERR_FIRST: u32 = 1u32;
pub const RULE_ERR_LAST: u32 = 13u32;
pub const RULE_ERR_LOAD: u32 = 2u32;
pub const RULE_ERR_NO_FOLDER: u32 = 6u32;
pub const RULE_ERR_NO_RIGHTS: u32 = 7u32;
pub const RULE_ERR_NO_SENDAS: u32 = 9u32;
pub const RULE_ERR_NO_TEMPLATE: u32 = 10u32;
pub const RULE_ERR_PARSING: u32 = 4u32;
pub const RULE_ERR_QUOTA_EXCEEDED: u32 = 12u32;
pub const RULE_ERR_TOO_MANY_RECIPS: u32 = 13u32;
pub const RULE_ERR_UNKNOWN: u32 = 1u32;
pub const SAVEBODY_KEEPBOUNDARY: u32 = 1u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct SAVEOPTS(pub i32);
pub const SAVEOPTS_NOSAVE: SAVEOPTS = SAVEOPTS(1i32);
pub const SAVEOPTS_PROMPTSAVE: SAVEOPTS = SAVEOPTS(2i32);
pub const SAVEOPTS_SAVEIFDIRTY: SAVEOPTS = SAVEOPTS(0i32);
pub const SAVE_FORMAT_RICHTEXT: u32 = 2u32;
pub const SAVE_FORMAT_TEXT: u32 = 1u32;
pub const SAVE_RFC1521: MIMESAVETYPE = MIMESAVETYPE(1i32);
pub const SAVE_RFC822: MIMESAVETYPE = MIMESAVETYPE(0i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SAndRestriction {
    pub cRes: u32,
    pub lpRes: *mut SRestriction,
}
impl Default for SAndRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SAnnotationRestriction {
    pub cValues: u32,
    pub lpRes: *mut SRestriction,
    pub lpProp: *mut SPropValue,
}
impl Default for SAnnotationRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SAppTimeArray {
    pub cValues: u32,
    pub lpat: *mut f64,
}
impl Default for SAppTimeArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SBinary {
    pub cb: u32,
    pub lpb: *mut u8,
}
impl Default for SBinary {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SBinaryArray {
    pub cValues: u32,
    pub lpbin: *mut SBinary,
}
impl Default for SBinaryArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SBitMaskRestriction {
    pub relBMR: u32,
    pub ulPropTag: u32,
    pub ulMask: u32,
}
impl Default for SBitMaskRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SCommentRestriction {
    pub cValues: u32,
    pub lpRes: *mut SRestriction,
    pub lpProp: *mut SPropValue,
}
impl Default for SCommentRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SComparePropsRestriction {
    pub relop: u32,
    pub ulPropTag1: u32,
    pub ulPropTag2: u32,
}
impl Default for SComparePropsRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SContentRestriction {
    pub ulFuzzyLevel: u32,
    pub ulPropTag: u32,
    pub lpProp: *mut SPropValue,
}
impl Default for SContentRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SCountRestriction {
    pub ulCount: u32,
    pub lpRes: *mut SRestriction,
}
impl Default for SCountRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SCurrencyArray {
    pub cValues: u32,
    pub lpcur: *mut windows::Win32::System::Com::CY,
}
impl Default for SCurrencyArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SDateTimeArray {
    pub cValues: u32,
    pub lpft: *mut windows::Win32::Foundation::FILETIME,
}
impl Default for SDateTimeArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SDoubleArray {
    pub cValues: u32,
    pub lpdbl: *mut f64,
}
impl Default for SDoubleArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const SEARCH_FOREGROUND: u32 = 8u32;
pub const SEARCH_REBUILD: u32 = 2u32;
pub const SEARCH_RECURSIVE: u32 = 4u32;
pub const SEARCH_RUNNING: u32 = 1u32;
pub const SECURITY_DESCRIPTOR_TRANSFER_VERSION: u32 = 3u32;
pub const SECURITY_ENCRYPTED: u32 = 2u32;
pub const SECURITY_SIGNED: u32 = 1u32;
pub const SEF_ENCRYPTWITHNOSENDERCERT: u32 = 1u32;
pub const SEF_MASK: u32 = 65535u32;
pub const SEF_SENDERSCERTPROVIDED: u32 = 2u32;
pub const SENSITIVITY_COMPANY_CONFIDENTIAL: u32 = 3u32;
pub const SENSITIVITY_NONE: u32 = 0u32;
pub const SENSITIVITY_PERSONAL: u32 = 1u32;
pub const SENSITIVITY_PRIVATE: u32 = 2u32;
pub type SERVICEWIZARDDLGPROC = Option<
    unsafe extern "system" fn(
        hdlg: windows::Win32::Foundation::HWND,
        wmsgid: u32,
        wparam: windows::Win32::Foundation::WPARAM,
        lparam: windows::Win32::Foundation::LPARAM,
    ) -> windows_core::BOOL,
>;
pub const SERVICE_CREATE_WITH_STORE: u32 = 4u32;
pub const SERVICE_DEFAULT_STORE: u32 = 1u32;
pub const SERVICE_LOGON_FAILED: u32 = 32u32;
pub const SERVICE_NO_PRIMARY_IDENTITY: u32 = 32u32;
pub const SERVICE_PRIMARY_IDENTITY: u32 = 8u32;
pub const SERVICE_SINGLE_COPY: u32 = 2u32;
pub const SERVICE_UI_ALLOWED: u32 = 16u32;
pub const SERVICE_UI_ALWAYS: u32 = 2u32;
pub const SETID_AirSync: windows_core::GUID =
    windows_core::GUID::from_u128(0x71035549_0739_4dcb_9163_00f0580dbbdf);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SExistRestriction {
    pub ulReserved1: u32,
    pub ulPropTag: u32,
    pub ulReserved2: u32,
}
impl Default for SExistRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const SF_DISABLE_STARTUP_SYNC: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SGuidArray {
    pub cValues: u32,
    pub lpguid: *mut windows_core::GUID,
}
impl Default for SGuidArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const SHALLOW_SEARCH: u32 = 8u32;
pub const SHOW_SOFT_DELETES: u32 = 2u32;
pub const SHOW_SUBFOLDERS: u32 = 4u32;
pub const SHOW_XP_SESSION_UI: u32 = 4194304u32;
pub const SIMPLE: CERTNAMETYPE = CERTNAMETYPE(0i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SLPSTRArray {
    pub cValues: u32,
    pub lppszA: *mut windows_core::PSTR,
}
impl Default for SLPSTRArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SLargeIntegerArray {
    pub cValues: u32,
    pub lpli: *mut i64,
}
impl Default for SLargeIntegerArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SLongArray {
    pub cValues: u32,
    pub lpl: *mut i32,
}
impl Default for SLongArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Debug, PartialEq)]
pub struct SMAPIFormInfoArray {
    pub cForms: u32,
    pub aFormInfo: [core::mem::ManuallyDrop<Option<IMAPIFormInfo>>; 1],
}
impl Default for SMAPIFormInfoArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct SMAPIFormProp {
    pub ulFlags: u32,
    pub nPropType: u32,
    pub nmid: MAPINAMEID,
    pub pszDisplayName: *mut i8,
    pub nSpecialType: u32,
    pub u: SMAPIFormProp_0,
}
impl Default for SMAPIFormProp {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union SMAPIFormProp_0 {
    pub s1: SMAPIFormProp_0_0,
}
impl Default for SMAPIFormProp_0 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct SMAPIFormProp_0_0 {
    pub nmidIdx: MAPINAMEID,
    pub cfpevAvailable: u32,
    pub pfpevAvailable: *mut SMAPIFormPropEnumVal,
}
impl Default for SMAPIFormProp_0_0 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct SMAPIFormPropArray {
    pub cProps: u32,
    pub ulPad: u32,
    pub aFormProp: [SMAPIFormProp; 1],
}
impl Default for SMAPIFormPropArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SMAPIFormPropEnumVal {
    pub pszDisplayName: *mut i8,
    pub nVal: u32,
}
impl Default for SMAPIFormPropEnumVal {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SMAPIVerb {
    pub lVerb: i32,
    pub szVerbname: *mut i8,
    pub fuFlags: u32,
    pub grfAttribs: u32,
    pub ulFlags: u32,
}
impl Default for SMAPIVerb {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SMAPIVerbArray {
    pub cMAPIVerb: u32,
    pub aMAPIVerb: [SMAPIVerb; 1],
}
impl Default for SMAPIVerbArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SMessageClassArray {
    pub cValues: u32,
    pub aMessageClass: [windows_core::PSTR; 1],
}
impl Default for SMessageClassArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SNotRestriction {
    pub ulReserved: u32,
    pub lpRes: *mut SRestriction,
}
impl Default for SNotRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const SOF_UNIQUEFILENAME: u32 = 2147483648u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SOrRestriction {
    pub cRes: u32,
    pub lpRes: *mut SRestriction,
}
impl Default for SOrRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const SPAMFILTER_ONSAVE: u32 = 128u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SPropAttrArray {
    pub cValues: u32,
    pub aPropAttr: [u32; 1],
}
impl Default for SPropAttrArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SPropProblem {
    pub ulIndex: u32,
    pub ulPropTag: u32,
    pub scode: i32,
}
impl Default for SPropProblem {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SPropProblemArray {
    pub cProblem: u32,
    pub aProblem: [SPropProblem; 1],
}
impl Default for SPropProblemArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SPropTagArray {
    pub cValues: u32,
    pub aulPropTag: [u32; 1],
}
impl Default for SPropTagArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct SPropValue {
    pub ulPropTag: u32,
    pub dwAlignPad: u32,
    pub Value: __UPV,
}
impl Default for SPropValue {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SPropertyRestriction {
    pub relop: u32,
    pub ulPropTag: u32,
    pub lpProp: *mut SPropValue,
}
impl Default for SPropertyRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SRealArray {
    pub cValues: u32,
    pub lpflt: *mut f32,
}
impl Default for SRealArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct SRestriction {
    pub rt: u32,
    pub res: SRestriction_0,
}
impl Default for SRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union SRestriction_0 {
    pub resCompareProps: SComparePropsRestriction,
    pub resAnd: SAndRestriction,
    pub resOr: SOrRestriction,
    pub resNot: SNotRestriction,
    pub resContent: SContentRestriction,
    pub resProperty: SPropertyRestriction,
    pub resBitMask: SBitMaskRestriction,
    pub resSize: SSizeRestriction,
    pub resExist: SExistRestriction,
    pub resSub: SSubRestriction,
    pub resComment: SCommentRestriction,
    pub resAnnotation: SAnnotationRestriction,
    pub resCount: SCountRestriction,
}
impl Default for SRestriction_0 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SRow {
    pub ulAdrEntryPad: u32,
    pub cValues: u32,
    pub lpProps: *mut SPropValue,
}
impl Default for SRow {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SRowSet {
    pub cRows: u32,
    pub aRow: [SRow; 1],
}
impl Default for SRowSet {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SShortArray {
    pub cValues: u32,
    pub lpi: *mut i16,
}
impl Default for SShortArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SSizeRestriction {
    pub relop: u32,
    pub ulPropTag: u32,
    pub cb: u32,
}
impl Default for SSizeRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SSortOrder {
    pub ulPropTag: u32,
    pub ulOrder: u32,
}
impl Default for SSortOrder {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SSortOrderSet {
    pub cSorts: u32,
    pub cCategories: u32,
    pub cExpanded: u32,
    pub aSort: [SSortOrder; 1],
}
impl Default for SSortOrderSet {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SSubRestriction {
    pub ulSubObject: u32,
    pub lpRes: *mut SRestriction,
}
impl Default for SSubRestriction {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const STATUSROW_UPDATE: u32 = 268435456u32;
pub const STATUS_AVAILABLE: u32 = 1u32;
pub const STATUS_CHANGE_PASSWORD: u32 = 4u32;
pub const STATUS_DEFAULT_OUTBOUND: u32 = 1u32;
pub const STATUS_DEFAULT_STORE: u32 = 2u32;
pub const STATUS_FAILURE: u32 = 4u32;
pub const STATUS_FLUSH_QUEUES: u32 = 8u32;
pub const STATUS_INBOUND_ACTIVE: u32 = 131072u32;
pub const STATUS_INBOUND_ENABLED: u32 = 65536u32;
pub const STATUS_INBOUND_FLUSH: u32 = 262144u32;
pub const STATUS_NEED_IPM_TREE: u32 = 2048u32;
pub const STATUS_NO_DEFAULT_STORE: u32 = 64u32;
pub const STATUS_NO_PRIMARY_IDENTITY: u32 = 32u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct STATUS_OBJECT_NOTIFICATION {
    pub cbEntryID: u32,
    pub lpEntryID: *mut ENTRYID,
    pub cValues: u32,
    pub lpPropVals: *mut SPropValue,
}
impl Default for STATUS_OBJECT_NOTIFICATION {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const STATUS_OFFLINE: u32 = 2u32;
pub const STATUS_OUTBOUND_ACTIVE: u32 = 2097152u32;
pub const STATUS_OUTBOUND_ENABLED: u32 = 1048576u32;
pub const STATUS_OUTBOUND_FLUSH: u32 = 4194304u32;
pub const STATUS_OWN_STORE: u32 = 256u32;
pub const STATUS_PRIMARY_IDENTITY: u32 = 4u32;
pub const STATUS_PRIMARY_STORE: u32 = 4096u32;
pub const STATUS_REMOTE_ACCESS: u32 = 8388608u32;
pub const STATUS_SECONDARY_STORE: u32 = 8192u32;
pub const STATUS_SETTINGS_DIALOG: u32 = 2u32;
pub const STATUS_SIMPLE_STORE: u32 = 8u32;
pub const STATUS_TEMP_SECTION: u32 = 128u32;
pub const STATUS_VALIDATE_STATE: u32 = 1u32;
pub const STATUS_XP_PREFER_LAST: u32 = 16u32;
pub const STGSTRM_CREATE: u32 = 4096u32;
pub const STGSTRM_CURRENT: u32 = 268435456u32;
pub const STGSTRM_MODIFY: u32 = 2u32;
pub const STGSTRM_RESET: u32 = 0u32;
pub const STOCK_REPLY_TEMPLATE: u32 = 2u32;
pub const STOP_SEARCH: u32 = 1u32;
pub const STORE_ATTACH_OK: u32 = 32u32;
pub const STORE_CATEGORIZE_OK: u32 = 1024u32;
pub const STORE_CREATE_OK: u32 = 16u32;
pub const STORE_ENTRYID_UNIQUE: u32 = 1u32;
pub const STORE_HAS_SEARCHES: u32 = 16777216u32;
pub const STORE_ITEMPROC: u32 = 2097152u32;
pub const STORE_MODIFY_OK: u32 = 8u32;
pub const STORE_MV_PROPS_OK: u32 = 512u32;
pub const STORE_NOTIFY_OK: u32 = 256u32;
pub const STORE_OLE_OK: u32 = 64u32;
pub const STORE_PUBLIC_FOLDERS: u32 = 16384u32;
pub const STORE_READONLY: u32 = 2u32;
pub const STORE_RESTRICTION_OK: u32 = 4096u32;
pub const STORE_RTF_OK: u32 = 2048u32;
pub const STORE_SEARCH_OK: u32 = 4u32;
pub const STORE_SORT_OK: u32 = 8192u32;
pub const STORE_SUBMIT_OK: u32 = 128u32;
pub const STORE_UNCOMPRESSED_RTF: u32 = 32768u32;
pub const STORE_UNICODE_OK: u32 = 262144u32;
pub const STREAM_APPEND: u32 = 4u32;
pub const ST_CLEAR_OOF_HIST: u32 = 2147483648u32;
pub const ST_DISABLED: u32 = 0u32;
pub const ST_ENABLED: u32 = 1u32;
pub const ST_ERROR: u32 = 2u32;
pub const ST_EXIT_LEVEL: u32 = 16u32;
pub const ST_KEEP_OOF_HIST: u32 = 8u32;
pub const ST_ONLY_WHEN_OOF: u32 = 4u32;
pub const ST_RULE_PARSE_ERROR: u32 = 64u32;
pub const ST_SKIP_IF_SCL_IS_SAFE: u32 = 32u32;
pub const SUBMITFLAG_LOCKED: u32 = 1u32;
pub const SUBMITFLAG_PREPROCESS: u32 = 2u32;
pub const SUCCESS_SUCCESS: u32 = 0u32;
pub const SUPPRESS_RECEIPT: u32 = 1u32;
pub const SUPPRESS_UI: u32 = 1u32;
pub const SUPRESS_NOTIFICATIONS_ON_MY_ACTIONS: u32 = 4096u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SWStringArray {
    pub cValues: u32,
    pub lppszW: *mut windows_core::PWSTR,
}
impl Default for SWStringArray {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const SYNC_ASSOCIATED: u32 = 16u32;
pub const SYNC_BEST_BODY: u32 = 8192u32;
pub const SYNC_CATCHUP: u32 = 1024u32;
pub const SYNC_DEFER_CONFIG: u32 = 262144u32;
pub const SYNC_EXPIRY: u32 = 2u32;
pub const SYNC_FORCE_UNICODE: u32 = 262144u32;
pub const SYNC_FXRECOVERMODE: u32 = 65536u32;
pub const SYNC_IGNORE_SPECIFIED_ON_ASSOCIATED: u32 = 16384u32;
pub const SYNC_LIMITED_IMESSAGE: u32 = 512u32;
pub const SYNC_MSG_SELECTIVE: u32 = 4096u32;
pub const SYNC_NEW_MESSAGE: u32 = 2048u32;
pub const SYNC_NORMAL: u32 = 32u32;
pub const SYNC_NO_CONFLICTS: u32 = 64u32;
pub const SYNC_NO_DELETIONS: u32 = 2u32;
pub const SYNC_NO_FOREIGN_KEYS: u32 = 256u32;
pub const SYNC_NO_SOFT_DELETIONS: u32 = 4u32;
pub const SYNC_ONLY_SPECIFIED_PROPS: u32 = 128u32;
pub const SYNC_PROGRESS_MODE: u32 = 32768u32;
pub const SYNC_READ: u32 = 1u32;
pub const SYNC_READ_STATE: u32 = 8u32;
pub const SYNC_SOFT_DELETE: u32 = 1u32;
pub const SYNC_UNICODE: u32 = 1u32;
pub const SZ_HPC_V1: windows_core::PCSTR = windows_core::s!("Software\\Microsoft\\Pegasus");
pub const SZ_HPC_V1_0: windows_core::PCSTR = windows_core::s!("InstalledDir");
pub const SZ_HPC_V1_MAJOR: windows_core::PCSTR = windows_core::s!("MajorVersion");
pub const SZ_HPC_V1_MINOR: windows_core::PCSTR = windows_core::s!("MinorVersion");
pub const SZ_HPC_V2: windows_core::PCSTR =
    windows_core::s!("Software\\Microsoft\\Windows CE Services");
pub const SZ_HPC_V2_MAJOR: windows_core::PCSTR = windows_core::s!("MajorVersion");
pub const SZ_HPC_V2_MINOR: windows_core::PCSTR = windows_core::s!("MinorVersion");
pub const SZ_NO_OST: windows_core::PCSTR = windows_core::s!("NoOST");
pub const SZ_OUTL_OST_OPTIONS: windows_core::PCSTR =
    windows_core::s!("Software\\Microsoft\\Office\\8.0\\Outlook\\OST");
pub const TABLE_CHANGED: u32 = 1u32;
pub const TABLE_ERROR: u32 = 2u32;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct TABLE_NOTIFICATION {
    pub ulTableEvent: u32,
    pub hResult: windows_core::HRESULT,
    pub propIndex: SPropValue,
    pub propPrior: SPropValue,
    pub row: SRow,
    pub ulPad: u32,
}
impl Default for TABLE_NOTIFICATION {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const TABLE_RELOAD: u32 = 9u32;
pub const TABLE_RESTRICT_DONE: u32 = 7u32;
pub const TABLE_ROW_ADDED: u32 = 3u32;
pub const TABLE_ROW_DELETED: u32 = 4u32;
pub const TABLE_ROW_MODIFIED: u32 = 5u32;
pub const TABLE_SETCOL_DONE: u32 = 8u32;
pub const TABLE_SORT_ASCEND: u32 = 0u32;
pub const TABLE_SORT_CATEG_MAX: u32 = 4u32;
pub const TABLE_SORT_CATEG_MIN: u32 = 8u32;
pub const TABLE_SORT_COMBINE: u32 = 2u32;
pub const TABLE_SORT_DESCEND: u32 = 1u32;
pub const TABLE_SORT_DONE: u32 = 6u32;
pub const TAD_ALL_ROWS: u32 = 1u32;
pub const TBLSTAT_COMPLETE: u32 = 0u32;
pub const TBLSTAT_QCHANGED: u32 = 7u32;
pub const TBLSTAT_RESTRICTING: u32 = 14u32;
pub const TBLSTAT_RESTRICT_ERROR: u32 = 15u32;
pub const TBLSTAT_SETCOL_ERROR: u32 = 13u32;
pub const TBLSTAT_SETTING_COLS: u32 = 11u32;
pub const TBLSTAT_SORTING: u32 = 9u32;
pub const TBLSTAT_SORT_ERROR: u32 = 10u32;
pub const TBLTYPE_DYNAMIC: u32 = 2u32;
pub const TBLTYPE_KEYSET: u32 = 1u32;
pub const TBLTYPE_SNAPSHOT: u32 = 0u32;
pub const TBL_ALL_COLUMNS: u32 = 1u32;
pub const TBL_ASYNC: u32 = 1u32;
pub const TBL_BATCH: u32 = 2u32;
pub const TBL_COLLAPSED_CATEGORY: u32 = 4u32;
pub const TBL_EMPTY_CATEGORY: u32 = 2u32;
pub const TBL_EXPANDED_CATEGORY: u32 = 3u32;
pub const TBL_LEAF_ROW: u32 = 1u32;
pub const TBL_NOADVANCE: u32 = 1u32;
pub const TBL_NOWAIT: u32 = 1u32;
pub const TIME_ZONE_ID_DAYLIGHT: u32 = 2u32;
pub const TIME_ZONE_ID_STANDARD: u32 = 1u32;
pub const TIME_ZONE_ID_UNKNOWN: u32 = 0u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TRACEENTRY {
    pub lAction: i32,
    pub ftArrivalTime: windows::Win32::Foundation::FILETIME,
    pub ftDeferredTime: windows::Win32::Foundation::FILETIME,
    pub rgchADMDName: [i8; 20],
    pub rgchCountryName: [i8; 4],
    pub rgchPRMDId: [i8; 20],
    pub rgchAttADMDName: [i8; 20],
    pub rgchAttCountryName: [i8; 4],
    pub rgchAttPRMDId: [i8; 19],
    pub bAdditionalActions: u8,
}
impl Default for TRACEENTRY {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TRACEINFO {
    pub cEntries: u32,
    pub rgtraceentry: [TRACEENTRY; 1],
}
impl Default for TRACEINFO {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const TRANSFER_COPYFOLDER: u32 = 4u32;
pub const TRANSFER_COPYMESSAGES: u32 = 3u32;
pub const TRANSFER_COPYPROPS: u32 = 2u32;
pub const TRANSFER_COPYTO: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TRANSMITINFO {
    pub ietCurrent: ENCODINGTYPE,
    pub ietXmitMime: ENCODINGTYPE,
    pub ietXmit822: ENCODINGTYPE,
    pub cbLongestLine: u32,
    pub cExtended: u32,
    pub ulPercentExt: u32,
    pub cbSize: u32,
    pub cLines: u32,
}
impl Default for TRANSMITINFO {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const TRANSPORT_DOWNLOAD: u32 = 1u32;
pub const TRANSPORT_UPLOAD: u32 = 2u32;
pub const TRUNCATE_EXISTING: u32 = 5u32;
pub const TXT_HTML: u32 = 2u32;
pub const TXT_PLAIN: u32 = 1u32;
pub const TYPEDID_MASK: u32 = 65535u32;
pub const UI_CURRENT_PROVIDER_FIRST: u32 = 4u32;
pub const UI_READONLY: u32 = 1u32;
pub const UI_SERVICE: u32 = 2u32;
pub const UNLOCK_BLOCKING_MID_LOCK_ALL: u32 = 4u32;
pub const UNLOCK_BLOCKING_MID_LOCK_LOGON_ONLY: u32 = 8u32;
pub const UNLOCK_CHECKIN_ABORT: u32 = 1u32;
pub const UNLOCK_CHECKIN_KEEP_LOCKED: u32 = 2u32;
pub const UNLOCK_NULL_RESOURCE: u32 = 16u32;
pub const UNLOCK_WRITE_THROUGH_GOP: u32 = 65536u32;
pub const URL_ATTACH_GENERATE_CID: u32 = 2u32;
pub const URL_ATTACH_INTO_MIXED: u32 = 1u32;
pub const URL_ATTACH_SET_CNTTYPE: u32 = 4u32;
pub const URL_RESOLVE_RENDERED: u32 = 1u32;
pub const URL_RESULVE_NO_BASE: u32 = 2u32;
pub const VCDIR_DELETE: u32 = 65536u32;
pub const VCDIR_MOVE: u32 = 262144u32;
pub const VCDIR_NEXT: u32 = 1u32;
pub const VCDIR_PREV: u32 = 2u32;
pub const VCSTATUS_COPY: u32 = 131072u32;
pub const VCSTATUS_DELETE: u32 = 65536u32;
pub const VCSTATUS_DELETE_IS_MOVE: u32 = 1048576u32;
pub const VCSTATUS_INTERACTIVE: u32 = 8u32;
pub const VCSTATUS_MODAL: u32 = 4u32;
pub const VCSTATUS_MOVE: u32 = 262144u32;
pub const VCSTATUS_NEW_MESSAGE: u32 = 4194304u32;
pub const VCSTATUS_NEXT: u32 = 1u32;
pub const VCSTATUS_PREV: u32 = 2u32;
pub const VCSTATUS_READONLY: u32 = 16u32;
pub const VCSTATUS_SAVE: u32 = 2097152u32;
pub const VCSTATUS_SUBMIT: u32 = 524288u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct WEBPAGEOPTIONS {
    pub cbSize: u32,
    pub dwFlags: u32,
    pub dwDelay: u32,
    pub wchQuote: u16,
}
impl Default for WEBPAGEOPTIONS {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub type WIZARDENTRY = Option<
    unsafe extern "system" fn(
        hproviderdllinstance: windows::Win32::Foundation::HINSTANCE,
        lppcsresourcename: *mut *mut i8,
        lppdlgproc: *mut windows::Win32::UI::WindowsAndMessaging::DLGPROC,
        lpmapiprop: windows_core::Ref<'_, IMAPIProp>,
        lpmapisupportobject: *mut core::ffi::c_void,
    ) -> u32,
>;
pub const WIZ_NEXT: u32 = 1035u32;
pub const WIZ_PREV: u32 = 1036u32;
pub const WIZ_QUERYNUMPAGES: u32 = 1034u32;
pub const WPF_ATTACHLINKS: u32 = 8u32;
pub const WPF_AUTOINLINE: u32 = 2u32;
pub const WPF_HTML: u32 = 1u32;
pub const WPF_IMAGESONLY: u32 = 16u32;
pub const WPF_NOMETACHARSET: u32 = 32u32;
pub const WPF_SLIDESHOW: u32 = 4u32;
pub const WSZ_URL_FLAT_FOLDER_SPACE: windows_core::PCWSTR = windows_core::w!("/-FlatUrlSpace-/");
pub const X500: CERTNAMETYPE = CERTNAMETYPE(2i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct X509CERTRESULT {
    pub cEntries: u32,
    pub rgcs: *mut CERTSTATE,
    pub rgpCert: *mut *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
}
impl Default for X509CERTRESULT {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub type XPPROVIDERINIT = Option<
    unsafe extern "system" fn(
        hinstance: windows::Win32::Foundation::HINSTANCE,
        lpmalloc: windows_core::Ref<'_, windows::Win32::System::Com::IMalloc>,
        lpallocatebuffer: LPALLOCATEBUFFER,
        lpallocatemore: LPALLOCATEMORE,
        lpfreebuffer: LPFREEBUFFER,
        ulflags: u32,
        ulmapiver: u32,
        lpulproviderver: *mut u32,
        lppxpprovider: windows_core::OutRef<'_, IXPProvider>,
    ) -> windows_core::HRESULT,
>;
#[repr(C)]
#[derive(Clone, Copy)]
pub union __UPV {
    pub i: i16,
    pub l: i32,
    pub ul: u32,
    pub lpv: *mut core::ffi::c_void,
    pub flt: f32,
    pub dbl: f64,
    pub b: u16,
    pub cur: windows::Win32::System::Com::CY,
    pub at: f64,
    pub ft: windows::Win32::Foundation::FILETIME,
    pub lpszA: windows_core::PSTR,
    pub bin: SBinary,
    pub lpszW: windows_core::PWSTR,
    pub lpguid: *mut windows_core::GUID,
    pub li: i64,
    pub MVi: SShortArray,
    pub MVl: SLongArray,
    pub MVflt: SRealArray,
    pub MVdbl: SDoubleArray,
    pub MVcur: SCurrencyArray,
    pub MVat: SAppTimeArray,
    pub MVft: SDateTimeArray,
    pub MVbin: SBinaryArray,
    pub MVszA: SLPSTRArray,
    pub MVszW: SWStringArray,
    pub MVguid: SGuidArray,
    pub MVli: SLargeIntegerArray,
    pub err: i32,
    pub x: i32,
}
impl Default for __UPV {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
pub const cchProfileNameMax: u32 = 64u32;
pub const cchProfilePassMax: u32 = 64u32;
pub const cwchUrlFlatFolderSpace: u32 = 16u32;
pub const fMapiUnicode: u32 = 2147483648u32;
pub const fVersionedDelete: u32 = 1u32;
pub const fVersionedMoveIn: u32 = 16u32;
pub const fVersionedMoveOut: u32 = 32u32;
pub const fVersionedPin: u32 = 4u32;
pub const fVersionedUnDelete: u32 = 2u32;
pub const fVersionedUnPin: u32 = 8u32;
pub const fnevCriticalError: u32 = 1u32;
pub const fnevExtended: u32 = 2147483648u32;
pub const fnevNewMail: u32 = 2u32;
pub const fnevObjectCopied: u32 = 64u32;
pub const fnevObjectCreated: u32 = 4u32;
pub const fnevObjectDeleted: u32 = 8u32;
pub const fnevObjectModified: u32 = 16u32;
pub const fnevObjectMoved: u32 = 32u32;
pub const fnevReservedForMapi: u32 = 1073741824u32;
pub const fnevSearchComplete: u32 = 128u32;
pub const fnevStatusObjectModified: u32 = 512u32;
pub const fnevTableModified: u32 = 256u32;
pub const frightsContact: i32 = 512i32;
pub const frightsCreate: i32 = 2i32;
pub const frightsCreateSubfolder: i32 = 128i32;
pub const frightsDeleteAny: i32 = 64i32;
pub const frightsDeleteOwned: i32 = 16i32;
pub const frightsEditAny: i32 = 32i32;
pub const frightsEditOwned: i32 = 8i32;
pub const frightsFreeBusyDetailed: i32 = 4096i32;
pub const frightsFreeBusySimple: i32 = 2048i32;
pub const frightsOwner: i32 = 256i32;
pub const frightsReadAny: i32 = 1i32;
pub const frightsVisible: i32 = 1024i32;
pub const fsdpermUserMailboxOwner: u32 = 1u32;
pub const fsdpermUserPrimaryUser: u32 = 4u32;
pub const fsdpermUserSendAs: u32 = 2u32;
pub const fsdrightAppendMsg: u32 = 4u32;
pub const fsdrightContact: u32 = 32768u32;
pub const fsdrightCreateContainer: u32 = 4u32;
pub const fsdrightCreateItem: u32 = 2u32;
pub const fsdrightDeleteOwnItem: u32 = 1024u32;
pub const fsdrightExecute: u32 = 32u32;
pub const fsdrightFreeBusyDetailed: u32 = 2u32;
pub const fsdrightFreeBusySimple: u32 = 1u32;
pub const fsdrightListContents: u32 = 1u32;
pub const fsdrightOwner: u32 = 16384u32;
pub const fsdrightReadAttributes: u32 = 128u32;
pub const fsdrightReadBody: u32 = 1u32;
pub const fsdrightReadProperty: u32 = 8u32;
pub const fsdrightReserved1: u32 = 64u32;
pub const fsdrightViewItem: u32 = 2048u32;
pub const fsdrightWriteAttributes: u32 = 256u32;
pub const fsdrightWriteBody: u32 = 2u32;
pub const fsdrightWriteOwnProperty: u32 = 512u32;
pub const fsdrightWriteProperty: u32 = 16u32;
pub const hrSuccess: u32 = 0u32;
pub const ichOpMapForward: u32 = 4u32;
pub const ichOpMapOpen: u32 = 1u32;
pub const ichOpMapPrint: u32 = 5u32;
pub const ichOpMapReplyToAll: u32 = 3u32;
pub const ichOpMapReplyToFolder: u32 = 8u32;
pub const ichOpMapReplyToSender: u32 = 2u32;
pub const ichOpMapReservedCompose: u32 = 0u32;
pub const ichOpMapReservedDelivery: u32 = 7u32;
pub const ichOpMapSaveAs: u32 = 6u32;
pub const lidOpMap: u32 = 1u32;
pub const pbExchangeProviderDelegateGuid: windows_core::PCSTR =
    windows_core::s!("\u{9e}\u{b4}w\u{0}t\u{e4}\u{11}\u{ce}\u{8c}^\u{0}\u{aa}\u{0}BT\u{e2}");
pub const pbExchangeProviderLocalStoreGuid: windows_core::PCSTR =
    windows_core::s!("-\u{e5}k\u{a1}dn\u{11}\u{d2}\u{8d}N\u{0}\u{c0}O\u{ae}#q");
pub const pbExchangeProviderPersistStoreGuid: windows_core::PCSTR =
    windows_core::s!("\u{98}\u{a2}=gb\u{cf}M4\u{82}y\u{db}\u{fa}jP\u{8b}1");
pub const pbExchangeProviderPrimaryUserGuid: windows_core::PCSTR =
    windows_core::s!("T\u{94}\u{a1}\u{c0})\u{7f}\u{10}\u{1b}\u{a5}\u{87}\u{8}\u{0}+*%\u{17}");
pub const pbExchangeProviderPublicGuid: windows_core::PCSTR =
    windows_core::s!("x\u{b2}\u{fa}p\u{af}\u{f7}\u{11}\u{cd}\u{9b}\u{c8}\u{0}\u{aa}\u{0}/\u{c4}Z");
pub const pbExchangeProviderXportGuid: windows_core::PCSTR = windows_core::s!(
    "\u{a9}\u{6}@\u{e0}\u{d6}\u{93}\u{11}\u{cd}\u{af}\u{95}\u{0}\u{aa}\u{0}J5\u{c3}"
);
pub const pbGlobalProfileSectionGuid: windows_core::PCSTR = windows_core::s!(
    "\u{13}\u{db}\u{b0}\u{c8}\u{aa}\u{5}\u{10}\u{1a}\u{9b}\u{b0}\u{0}\u{aa}\u{0}/\u{c4}Z"
);
pub const pidAdminMin: u32 = 26256u32;
pub const pidAttachReadOnlyMin: u32 = 26220u32;
pub const pidExchangeNonXmitReservedMin: u32 = 26080u32;
pub const pidExchangeXmitReservedMin: u32 = 16352u32;
pub const pidFolderMin: u32 = 26168u32;
pub const pidLISErrorCodeMax: u32 = 26032u32;
pub const pidLISErrorCodeMin: u32 = 26026u32;
pub const pidLISInterfacePropMax: u32 = 26080u32;
pub const pidLISInterfacePropMin: u32 = 26064u32;
pub const pidLISMsgFolderPropMax: u32 = 26048u32;
pub const pidLISMsgFolderPropMin: u32 = 26016u32;
pub const pidLocalStoreInternalMax: u32 = 26048u32;
pub const pidLocalStoreInternalMin: u32 = 25856u32;
pub const pidMAPIMin: u32 = 12288u32;
pub const pidMessageReadOnlyMin: u32 = 26176u32;
pub const pidMessageWriteableMin: u32 = 26200u32;
pub const pidProfileMin: u32 = 26112u32;
pub const pidRenMsgFldMin: u32 = 4224u32;
pub const pidSpecialMin: u32 = 26224u32;
pub const pidStoreMin: u32 = 26136u32;
pub const pidStoreNonTransMin: u32 = 3648u32;
pub const ptagLISErrorCode: u32 = 1705639939u32;
pub const ptagLISErrorItemType: u32 = 1705705475u32;
pub const ptagLISErrorItemUrl: u32 = 1705836575u32;
pub const ptagLISErrorLogUrl: u32 = 1701838879u32;
pub const ptagLISErrorOperation: u32 = 1705771011u32;
pub const ptagLISErrorSourceUrl: u32 = 1705902111u32;
pub const ptagLISExtendedErrorinfo: u32 = 1706033155u32;
pub const ptagLISModifiedPropertyList: u32 = 1705967647u32;
pub const ptagLISNewMail: u32 = 1707409419u32;
pub const ptagLISSubfolders: u32 = 1694498827u32;
pub const ptagLISUnreadCount: u32 = 1694564355u32;
pub const ptagSql: u32 = 1708130335u32;
pub const ptagSqlFrom: u32 = 1708261407u32;
pub const ptagSqlGroup: u32 = 1708458015u32;
pub const ptagSqlOrder: u32 = 1708392479u32;
pub const ptagSqlSelect: u32 = 1708195871u32;
pub const ptagSqlWhere: u32 = 1708326943u32;
pub const rightsAll: i32 = 1531i32;
pub const rightsNone: u32 = 0u32;
pub const rightsReadOnly: i32 = 1i32;
pub const sdrightsNone: u32 = 0u32;
pub const szDamMsgClass: windows_core::PCSTR =
    windows_core::s!("IPC.Microsoft Exchange 4.0.Deferred Action");
pub const szDemMsgClass: windows_core::PCSTR =
    windows_core::s!("IPC.Microsoft Exchange 4.0.Deferred Error");
pub const szExRuleMsgClass: windows_core::PCSTR = windows_core::s!("IPM.ExtendedRule.Message");
pub const szHrDispatchNotifications: windows_core::PCSTR =
    windows_core::s!("HrDispatchNotifications");
pub const szMAPIDLLSuffix: windows_core::PCSTR = windows_core::s!("32");
pub const szMAPINotificationMsg: windows_core::PCSTR =
    windows_core::s!("MAPI Notify window message");
pub const szOID_Microsoft_Encryption_Cert: windows_core::PCSTR =
    windows_core::s!("1.3.6.1.4.1.311.16.4");
pub const szOofTemplateMsgClassPrefix: windows_core::PCSTR =
    windows_core::s!("IPM.Note.Rules.OofTemplate.");
pub const szProviderModeratorRule: windows_core::PCSTR = windows_core::s!("MSFT:MR");
pub const szReplyTemplateMsgClassPrefix: windows_core::PCSTR =
    windows_core::s!("IPM.Note.Rules.ReplyTemplate.");
pub const szScCreateConversationIndex: windows_core::PCSTR =
    windows_core::s!("ScCreateConversationIndex");
pub const ulHierChanged: u32 = 1u32;
pub const wszExRuleMsgClass: windows_core::PCWSTR = windows_core::w!("IPM.ExtendedRule.Message");
pub const wszProviderModeratorRule: windows_core::PCWSTR = windows_core::w!("MSFT:MR");