[rustc.git] / vendor / winapi / src / um / vsbackup.rs

// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// All files in the project carrying such notice may not be copied, modified, or distributed
// except according to those terms.
//! Declaration of backup interfaces.
use ctypes::c_void;
use shared::guiddef::IID;
use shared::minwindef::{BOOL, BYTE, DWORD, UINT};
use shared::wtypes::BSTR;
use um::unknwnbase::{IUnknown, IUnknownVtbl};
use um::vss::{
    IVssAsync, IVssEnumObject, VSS_BACKUP_TYPE, VSS_ID, VSS_OBJECT_TYPE, VSS_PWSZ,
    VSS_RESTORE_TYPE, VSS_ROLLFORWARD_TYPE, VSS_SNAPSHOT_PROP, VSS_WRITER_STATE
};
use um::vswriter::{
    IVssWMDependency, IVssWMFiledesc, IVssWriterComponentsVtbl, VSS_COMPONENT_TYPE,
    VSS_FILE_RESTORE_STATUS, VSS_RESTOREMETHOD_ENUM, VSS_SOURCE_TYPE, VSS_USAGE_TYPE,
    VSS_WRITERRESTORE_ENUM
};
use um::winnt::{HRESULT, LONG, LPCWSTR};
DEFINE_GUID!{IID_IVssExamineWriterMetadata,
    0x902fcf7f, 0xb7fd, 0x42f8, 0x81, 0xf1, 0xb2, 0xe4, 0x00, 0xb1, 0xe5, 0xbd}
DEFINE_GUID!{IID_IVssExamineWriterMetadataEx,
    0x0c0e5ec0, 0xca44, 0x472b, 0xb7, 0x02, 0xe6, 0x52, 0xdb, 0x1c, 0x04, 0x51}
DEFINE_GUID!{IID_IVssBackupComponents,
    0x665c1d5f, 0xc218, 0x414d, 0xa0, 0x5d, 0x7f, 0xef, 0x5f, 0x9d, 0x5c, 0x86}
DEFINE_GUID!{IID_IVssBackupComponentsEx,
    0x963f03ad, 0x9e4c, 0x4a34, 0xac, 0x15, 0xe4, 0xb6, 0x17, 0x4e, 0x50, 0x36}
STRUCT!{struct VSS_COMPONENTINFO {
    type_: VSS_COMPONENT_TYPE, // type is a keyword in rust
    bstrLogicalPath: BSTR,
    bstrComponentName: BSTR,
    bstrCaption: BSTR,
    pbIcon: *mut BYTE,
    cbIcon: UINT,
    bRestoreMetadata: bool,
    bNotifyOnBackupComplete: bool,
    bSelectable: bool,
    bSelectableForRestore: bool,
    dwComponentFlags: DWORD,
    cFileCount: UINT,
    cDatabases: UINT,
    cLogFiles: UINT,
    cDependencies: UINT,
}}
pub type PVSSCOMPONENTINFO = *const VSS_COMPONENTINFO;
RIDL!{#[uuid(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)]
interface IVssWMComponent(IVssWMComponentVtbl): IUnknown(IUnknownVtbl) {
    fn GetComponentInfo(
        ppInfo: *mut PVSSCOMPONENTINFO,
    ) -> HRESULT,
    fn FreeComponentInfo(
        pInfo: PVSSCOMPONENTINFO,
    ) -> HRESULT,
    fn GetFile(
        iFile: UINT,
        ppFiledesc: *mut *mut IVssWMFiledesc,
    ) -> HRESULT,
    fn GetDatabaseFile(
        iDBFile: UINT,
        ppFiledesc: *mut *mut IVssWMFiledesc,
    ) -> HRESULT,
    fn GetDatabaseLogFile(
        iDbLogFile: UINT,
        ppFiledesc: *mut *mut IVssWMFiledesc,
    ) -> HRESULT,
    fn GetDependency(
        iDependency: UINT,
        ppDependency: *mut *mut IVssWMDependency,
    ) -> HRESULT,
}}
RIDL!{#[uuid(0x902fcf7f, 0xb7fd, 0x42f8, 0x81, 0xf1, 0xb2, 0xe4, 0x00, 0xb1, 0xe5, 0xbd)]
interface IVssExamineWriterMetadata(IVssExamineWriterMetadataVtbl): IUnknown(IUnknownVtbl) {
    fn GetIdentity(
        pidInstance: *mut VSS_ID,
        pidWriter: *mut VSS_ID,
        pbstrWriterName: *mut BSTR,
        pUsage: *mut VSS_USAGE_TYPE,
        pSource: *mut VSS_SOURCE_TYPE,
    ) -> HRESULT,
    fn GetFileCounts(
        pcIncludeFiles: *mut UINT,
        pcExcludeFiles: *mut UINT,
        pcComponents: *mut UINT,
    ) -> HRESULT,
    fn GetIncludeFile(
        iFile: UINT,
        ppFiledesc: *mut *mut IVssWMFiledesc,
    ) -> HRESULT,
    fn GetExcludeFile(
        iFile: UINT,
        ppFiledesc: *mut *mut IVssWMFiledesc,
    ) -> HRESULT,
    fn GetComponent(
        iComponent: UINT,
        ppComponent: *mut *mut IVssWMComponent,
    ) -> HRESULT,
    fn GetRestoreMethod(
        pMethod: *mut VSS_RESTOREMETHOD_ENUM,
        pbstrService: *mut BSTR,
        pbstrUserProcedure: *mut BSTR,
        pwriterRestore: *mut VSS_WRITERRESTORE_ENUM,
        pbRebootRequired: *mut bool,
        pcMappings: *mut UINT,
    ) -> HRESULT,
    fn GetAlternateLocationMapping(
        iMapping: UINT,
        ppFiledesc: *mut *mut IVssWMFiledesc,
    ) -> HRESULT,
    fn GetBackupSchema(
        pdwSchemaMask: *mut DWORD,
    ) -> HRESULT,
    fn GetDocument(
        pDoc: *mut c_void,
    ) -> HRESULT, //TODO IXMLDOMDocument,
    fn SaveAsXML(
        pbstrXML: *mut BSTR,
    ) -> HRESULT,
    fn LoadFromXML(
        pbstrXML: *mut BSTR,
    ) -> HRESULT,
}}
RIDL!{#[uuid(0x0c0e5ec0, 0xca44, 0x472b, 0xb7, 0x02, 0xe6, 0x52, 0xdb, 0x1c, 0x04, 0x51)]
interface IVssExamineWriterMetadataEx(IVssExamineWriterMetadataExVtbl):
    IVssExamineWriterMetadata(IVssExamineWriterMetadataVtbl) {
    fn GetIdentityEx(
        pidInstance: *mut VSS_ID,
        pidWriter: *mut VSS_ID,
        pbstrWriterName: *mut BSTR,
        pbstrInstanceName: *mut BSTR,
        pUsage: *mut VSS_USAGE_TYPE,
        pSource: *mut VSS_SOURCE_TYPE,
    ) -> HRESULT,
}}
RIDL!{#[uuid(0xce115780, 0xa611, 0x431b, 0xb5, 0x7f, 0xc3, 0x83, 0x03, 0xab, 0x6a, 0xee)]
interface IVssExamineWriterMetadataEx2(IVssExamineWriterMetadataEx2Vtbl):
    IVssExamineWriterMetadataEx(IVssExamineWriterMetadataExVtbl) {
    fn GetVersion(
        pdwMajorVersion: *mut DWORD,
        pdwMinorVersion: *mut DWORD,
    ) -> HRESULT,
    fn GetExcludeFromSnapshotCount(
        pcExcludedFromSnapshot: *mut UINT,
    ) -> HRESULT,
    fn GetExcludeFromSnapshotFile(
        iFile: UINT,
        ppFiledesc: *mut *mut IVssWMFiledesc,
    ) -> HRESULT,
}}
#[repr(C)]
pub struct IVssWriterComponentsExt {
    pub lpVtbl: *const IVssWriterComponentsExtVtbl,
}
#[repr(C)]
pub struct IVssWriterComponentsExtVtbl {
    pub parent1: IVssWriterComponentsVtbl,
    pub parent2: IUnknownVtbl,
}
RIDL!{#[uuid(0x665c1d5f, 0xc218, 0x414d, 0xa0, 0x5d, 0x7f, 0xef, 0x5f, 0x9d, 0x5c, 0x86)]
interface IVssBackupComponents(IVssBackupComponentsVtbl): IUnknown(IUnknownVtbl) {
    fn GetWriterComponentsCount(
        pcComponents: *mut UINT,
    ) -> HRESULT,
    fn GetWriterComponents(
        iWriter: UINT,
        ppWriter: *mut *mut IVssWriterComponentsExt,
    ) -> HRESULT,
    fn InitializeForBackup(
        bstrXML: BSTR,
    ) -> HRESULT,
    fn SetBackupState(
        bSelectComponents: bool,
        bBackupBootableSystemState: bool,
        backupType: VSS_BACKUP_TYPE,
        bPartialFileSupport: bool,
    ) -> HRESULT,
    fn InitializeForRestore(
        bstrXML: BSTR,
    ) -> HRESULT,
    fn SetRestoreState(
        restoreType: VSS_RESTORE_TYPE,
    ) -> HRESULT,
    fn GatherWriterMetadata(
        pAsync: *mut *mut IVssAsync,
    ) -> HRESULT,
    fn GetWriterMetadataCount(
        pcWriters: *mut UINT,
    ) -> HRESULT,
    fn GetWriterMetadata(
        iWriter: UINT,
        pidInstance: *mut VSS_ID,
        ppMetadata: *mut *mut IVssExamineWriterMetadata,
    ) -> HRESULT,
    fn FreeWriterMetadata() -> HRESULT,
    fn AddComponent(
        instanceId: VSS_ID,
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
    ) -> HRESULT,
    fn PrepareForBackup(
        ppAsync: *mut *mut IVssAsync,
    ) -> HRESULT,
    fn AbortBackup() -> HRESULT,
    fn GatherWriterStatus(
        ppAsync: *mut *mut IVssAsync,
    ) -> HRESULT,
    fn GetWriterStatusCount(
        pcWriters: *mut UINT,
    ) -> HRESULT,
    fn FreeWriterStatus() -> HRESULT,
    fn GetWriterStatus(
        iWriter: UINT,
        pidInstance: *mut VSS_ID,
        pidWriter: *mut VSS_ID,
        pbstrWriter: *mut BSTR,
        pnStatus: *mut VSS_WRITER_STATE,
        phResultFailure: *mut HRESULT,
    ) -> HRESULT,
    fn SetBackupSucceeded(
        instanceId: VSS_ID,
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        bSucceded: bool,
    ) -> HRESULT,
    fn SetBackupOptions(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        wszBackupOptions: LPCWSTR,
    ) -> HRESULT,
    fn SetSelectedForRestore(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        bSelectedForRestore: bool,
    ) -> HRESULT,
    fn SetRestoreOptions(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        wszRestoreOptions: LPCWSTR,
    ) -> HRESULT,
    fn SetAdditionalRestores(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        bAdditionalRestores: bool,
    ) -> HRESULT,
    fn SetPreviousBackupStamp(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        wszPreviousBackupStamp: LPCWSTR,
    ) -> HRESULT,
    fn SaveAsXML(
        pbstrXML: *mut BSTR,
    ) -> HRESULT,
    fn BackupComplete(
        ppAsync: *mut *mut IVssAsync,
    ) -> HRESULT,
    fn AddAlternativeLocationMapping(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        wszPath: LPCWSTR,
        wszFilespec: LPCWSTR,
        bRecursive: bool,
        wszDestination: LPCWSTR,
    ) -> HRESULT,
    fn AddRestoreSubcomponent(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        wszSubComponentLogicalPath: LPCWSTR,
        wszSubComponentName: LPCWSTR,
        bRepair: bool,
    ) -> HRESULT,
    fn SetFileRestoreStatus(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        status: VSS_FILE_RESTORE_STATUS,
    ) -> HRESULT,
    fn AddNewTarget(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        wszPath: LPCWSTR,
        wszFileName: LPCWSTR,
        bRecursive: bool,
        wszAlternatePath: LPCWSTR,
    ) -> HRESULT,
    fn SetRangesFilePath(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        iPartialFile: UINT,
        wszRangesFile: LPCWSTR,
    ) -> HRESULT,
    fn PreRestore(
        ppAsync: *mut *mut IVssAsync,
    ) -> HRESULT,
    fn PostRestore(
        ppAsync: *mut *mut IVssAsync,
    ) -> HRESULT,
    fn SetContext(
        lContext: LONG,
    ) -> HRESULT,
    fn StartSnapshotSet(
        pSnapshotSetId: *mut VSS_ID,
    ) -> HRESULT,
    fn AddToSnapshotSet(
        pwszVolumeName: VSS_PWSZ,
        ProviderId: VSS_ID,
        pidSnapshot: *mut VSS_ID,
    ) -> HRESULT,
    fn DoSnapshotSet(
        ppAsync: *mut *mut IVssAsync,
    ) -> HRESULT,
    fn DeleteSnapshots(
        SourceObjectId: VSS_ID,
        eSourceObjectType: VSS_OBJECT_TYPE,
        bForceDelete: BOOL,
        plDeletedSnapshots: *mut LONG,
        pNondeletedSnapshotID: *mut VSS_ID,
    ) -> HRESULT,
    fn ImportSnapshots(
        ppAsync: *mut *mut IVssAsync,
    ) -> HRESULT,
    fn BreakSnapshotSet(
        SnapshotSetId: VSS_ID,
    ) -> HRESULT,
    fn GetSnapshotProperties(
        SnapshotId: VSS_ID,
        pProp: *mut VSS_SNAPSHOT_PROP,
    ) -> HRESULT,
    fn Query(
        QueriedObjectId: VSS_ID,
        eQueriedObjectType: VSS_OBJECT_TYPE,
        eReturnedObjectsType: VSS_OBJECT_TYPE,
        ppEnum: *mut *mut IVssEnumObject,
    ) -> HRESULT,
    fn IsVolumeSupported(
        ProviderId: VSS_ID,
        pwszVolumeName: VSS_PWSZ,
        pbSupportedByThisProvider: *mut BOOL,
    ) -> HRESULT,
    fn DisableWriterClasses(
        rgWriterClassId: *const VSS_ID,
        cClassId: UINT,
    ) -> HRESULT,
    fn EnableWriterClasses(
        rgWriterClassId: *const VSS_ID,
        cClassId: UINT,
    ) -> HRESULT,
    fn DisableWriterInstances(
        rgWriterInstanceId: *const VSS_ID,
        cInstanceId: UINT,
    ) -> HRESULT,
    fn ExposeSnapshot(
        SnapshotId: VSS_ID,
        wszPathFromRoot: VSS_PWSZ,
        lAttributes: LONG,
        wszExpose: VSS_PWSZ,
        pwszExposed: VSS_PWSZ,
    ) -> HRESULT,
    fn RevertToSnapshot(
        SnapshotId: VSS_ID,
        bForceDismount: BOOL,
    ) -> HRESULT,
    fn QueryRevertStatus(
        pwszVolume: VSS_PWSZ,
        ppAsync: *mut *mut IVssAsync,
    ) -> HRESULT,
}}
RIDL!{#[uuid(0x963f03ad, 0x9e4c, 0x4a34, 0xac, 0x15, 0xe4, 0xb6, 0x17, 0x4e, 0x50, 0x36)]
interface IVssBackupComponentsEx(IVssBackupComponentsExVtbl):
    IVssBackupComponents(IVssBackupComponentsVtbl) {
    fn GetWriterMetadataEx(
        iWriter: UINT,
        pidInstance: *mut VSS_ID,
        ppMetadata: *mut *mut IVssExamineWriterMetadataEx,
    ) -> HRESULT,
    fn SetSelectedForRestoreEx(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        bSelectedForRestore: bool,
        instanceId: VSS_ID,
    ) -> HRESULT,
}}
RIDL!{#[uuid(0xacfe2b3a, 0x22c9, 0x4ef8, 0xbd, 0x03, 0x2f, 0x9c, 0xa2, 0x30, 0x08, 0x4e)]
interface IVssBackupComponentsEx2(IVssBackupComponentsEx2Vtbl):
    IVssBackupComponentsEx(IVssBackupComponentsExVtbl) {
    fn UnexposeSnapshot(
        snapshotId: VSS_ID,
    ) -> HRESULT,
    fn SetAuthoritativeRestore(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        bAuth: bool,
    ) -> HRESULT,
    fn SetRollForward(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        rollType: VSS_ROLLFORWARD_TYPE,
        wszRollForwardPoint: LPCWSTR,
    ) -> HRESULT,
    fn SetRestoreName(
        writerId: VSS_ID,
        ct: VSS_COMPONENT_TYPE,
        wszLogicalPath: LPCWSTR,
        wszComponentName: LPCWSTR,
        wszRestoreName: LPCWSTR,
    ) -> HRESULT,
    fn BreakSnapshotSetEx(
        SnapshotSetID: VSS_ID,
        dwBreakFlags: DWORD,
        ppAsync: *mut *mut IVssAsync,
    ) -> HRESULT,
    fn PreFastRecovery(
        SnapshotSetID: VSS_ID,
        dwPreFastRecoveryFlags: DWORD,
        ppAsync: *mut *mut IVssAsync,
    ) -> HRESULT,
    fn FastRecovery(
        SnapshotSetID: VSS_ID,
        dwFastRecoveryFlags: DWORD,
        ppAsync: *mut *mut IVssAsync,
    ) -> HRESULT,
}}
RIDL!{#[uuid(0xc191bfbc, 0xb602, 0x4675, 0x8b, 0xd1, 0x67, 0xd6, 0x42, 0xf5, 0x29, 0xd5)]
interface IVssBackupComponentsEx3(IVssBackupComponentsEx3Vtbl):
    IVssBackupComponentsEx2(IVssBackupComponentsEx2Vtbl) {
    fn GetWriterStatusEx(
        iWriter: UINT,
        pidInstance: *mut VSS_ID,
        pidWriter: *mut VSS_ID,
        pbstrWriter: *mut BSTR,
        pnStatus: *mut VSS_WRITER_STATE,
        phrFailureWriter: *mut HRESULT,
        phrApplication: *mut HRESULT,
        pbstrApplicationMessage: *mut BSTR,
    ) -> HRESULT,
    fn AddSnapshotToRecoverySet(
        snapshotId: VSS_ID,
        dwFlags: DWORD,
        pwszDestinationVolume: VSS_PWSZ,
    ) -> HRESULT,
    fn RecoverSet(
        dwFlags: DWORD,
        ppAsync: *mut *mut IVssAsync,
    ) -> HRESULT,
    fn GetSessionId(
        idSession: *mut VSS_ID,
    ) -> HRESULT,
}}
RIDL!{#[uuid(0xf434c2fd, 0xb553, 0x4961, 0xa9, 0xf9, 0xa8, 0xe9, 0x0b, 0x67, 0x3e, 0x53)]
interface IVssBackupComponentsEx4(IVssBackupComponentsEx4Vtbl):
    IVssBackupComponentsEx3(IVssBackupComponentsEx3Vtbl) {
    fn GetRootAndLogicalPrefixPaths(
        pwszFilePath: VSS_PWSZ,
        ppwszRootPath: *mut VSS_PWSZ,
        ppwszLogicalPrefix: *mut VSS_PWSZ,
        bNormalizeFQDNforRootPath: BOOL,
    ) -> HRESULT,
}}
pub const VSS_SW_BOOTABLE_STATE: DWORD = 1;
extern "system" {
    #[link_name="CreateVssBackupComponentsInternal"]
    pub fn CreateVssBackupComponents(
        ppBackup: *mut *mut IVssBackupComponents,
    ) -> HRESULT;
    #[link_name="CreateVssExamineWriterMetadataInternal"]
    pub fn CreateVssExamineWriterMetadata(
        bstrXML: BSTR,
        ppMetadata: *mut *mut IVssExamineWriterMetadata,
    ) -> HRESULT;
    #[link_name="IsVolumeSnapshottedInternal"]
    pub fn IsVolumeSnapshotted(
        pwszVolumeName: VSS_PWSZ,
        pbSnapshotsPresent: *mut BOOL,
        plSnapshotCapability: *mut LONG,
    ) -> HRESULT;
    #[link_name="VssFreeSnapshotPropertiesInternal"]
    pub fn VssFreeSnapshotProperties(
        pProp: *mut VSS_SNAPSHOT_PROP,
    );
    #[link_name="GetProviderMgmtInterfaceInternal"]
    pub fn GetProviderMgmtInterface(
        ProviderId: VSS_ID,
        InterfaceId: IID,
        ppItf: *mut *mut IUnknown,
    ) -> HRESULT;
    #[link_name="ShouldBlockRevertInternal"]
    pub fn ShouldBlockRevert(
        wszVolumeName: LPCWSTR,
        pbBlock: *mut bool,
    ) -> HRESULT;
}
Commit	Line	Data
ff7c6d11 XL	1	// Licensed under the Apache License, Version 2.0
	2	// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
	3	// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
	4	// All files in the project carrying such notice may not be copied, modified, or distributed
	5	// except according to those terms.
	6	//! Declaration of backup interfaces.
	7	use ctypes::c_void;
	8	use shared::guiddef::IID;
	9	use shared::minwindef::{BOOL, BYTE, DWORD, UINT};
	10	use shared::wtypes::BSTR;
	11	use um::unknwnbase::{IUnknown, IUnknownVtbl};
	12	use um::vss::{
	13	IVssAsync, IVssEnumObject, VSS_BACKUP_TYPE, VSS_ID, VSS_OBJECT_TYPE, VSS_PWSZ,
	14	VSS_RESTORE_TYPE, VSS_ROLLFORWARD_TYPE, VSS_SNAPSHOT_PROP, VSS_WRITER_STATE
	15	};
	16	use um::vswriter::{
	17	IVssWMDependency, IVssWMFiledesc, IVssWriterComponentsVtbl, VSS_COMPONENT_TYPE,
	18	VSS_FILE_RESTORE_STATUS, VSS_RESTOREMETHOD_ENUM, VSS_SOURCE_TYPE, VSS_USAGE_TYPE,
	19	VSS_WRITERRESTORE_ENUM
	20	};
	21	use um::winnt::{HRESULT, LONG, LPCWSTR};
0bf4aa26 XL	22	DEFINE_GUID!{IID_IVssExamineWriterMetadata,
	23	0x902fcf7f, 0xb7fd, 0x42f8, 0x81, 0xf1, 0xb2, 0xe4, 0x00, 0xb1, 0xe5, 0xbd}
	24	DEFINE_GUID!{IID_IVssExamineWriterMetadataEx,
	25	0x0c0e5ec0, 0xca44, 0x472b, 0xb7, 0x02, 0xe6, 0x52, 0xdb, 0x1c, 0x04, 0x51}
	26	DEFINE_GUID!{IID_IVssBackupComponents,
	27	0x665c1d5f, 0xc218, 0x414d, 0xa0, 0x5d, 0x7f, 0xef, 0x5f, 0x9d, 0x5c, 0x86}
	28	DEFINE_GUID!{IID_IVssBackupComponentsEx,
	29	0x963f03ad, 0x9e4c, 0x4a34, 0xac, 0x15, 0xe4, 0xb6, 0x17, 0x4e, 0x50, 0x36}
ff7c6d11 XL	30	STRUCT!{struct VSS_COMPONENTINFO {
	31	type_: VSS_COMPONENT_TYPE, // type is a keyword in rust
	32	bstrLogicalPath: BSTR,
	33	bstrComponentName: BSTR,
	34	bstrCaption: BSTR,
	35	pbIcon: *mut BYTE,
	36	cbIcon: UINT,
	37	bRestoreMetadata: bool,
	38	bNotifyOnBackupComplete: bool,
	39	bSelectable: bool,
	40	bSelectableForRestore: bool,
	41	dwComponentFlags: DWORD,
	42	cFileCount: UINT,
	43	cDatabases: UINT,
	44	cLogFiles: UINT,
	45	cDependencies: UINT,
	46	}}
	47	pub type PVSSCOMPONENTINFO = *const VSS_COMPONENTINFO;
0bf4aa26	48	RIDL!{#[uuid(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)]
ff7c6d11 XL	49	interface IVssWMComponent(IVssWMComponentVtbl): IUnknown(IUnknownVtbl) {
	50	fn GetComponentInfo(
	51	ppInfo: *mut PVSSCOMPONENTINFO,
	52	) -> HRESULT,
	53	fn FreeComponentInfo(
	54	pInfo: PVSSCOMPONENTINFO,
	55	) -> HRESULT,
	56	fn GetFile(
	57	iFile: UINT,
	58	ppFiledesc: mut mut IVssWMFiledesc,
	59	) -> HRESULT,
	60	fn GetDatabaseFile(
	61	iDBFile: UINT,
	62	ppFiledesc: mut mut IVssWMFiledesc,
	63	) -> HRESULT,
	64	fn GetDatabaseLogFile(
	65	iDbLogFile: UINT,
	66	ppFiledesc: mut mut IVssWMFiledesc,
	67	) -> HRESULT,
	68	fn GetDependency(
	69	iDependency: UINT,
	70	ppDependency: mut mut IVssWMDependency,
	71	) -> HRESULT,
0bf4aa26 XL	72	}}
0bf4aa26 XL	73	RIDL!{#[uuid(0x902fcf7f, 0xb7fd, 0x42f8, 0x81, 0xf1, 0xb2, 0xe4, 0x00, 0xb1, 0xe5, 0xbd)]
ff7c6d11 XL	74	interface IVssExamineWriterMetadata(IVssExamineWriterMetadataVtbl): IUnknown(IUnknownVtbl) {
	75	fn GetIdentity(
	76	pidInstance: *mut VSS_ID,
	77	pidWriter: *mut VSS_ID,
	78	pbstrWriterName: *mut BSTR,
	79	pUsage: *mut VSS_USAGE_TYPE,
	80	pSource: *mut VSS_SOURCE_TYPE,
	81	) -> HRESULT,
	82	fn GetFileCounts(
	83	pcIncludeFiles: *mut UINT,
	84	pcExcludeFiles: *mut UINT,
	85	pcComponents: *mut UINT,
	86	) -> HRESULT,
	87	fn GetIncludeFile(
	88	iFile: UINT,
	89	ppFiledesc: mut mut IVssWMFiledesc,
	90	) -> HRESULT,
	91	fn GetExcludeFile(
	92	iFile: UINT,
	93	ppFiledesc: mut mut IVssWMFiledesc,
	94	) -> HRESULT,
	95	fn GetComponent(
	96	iComponent: UINT,
	97	ppComponent: mut mut IVssWMComponent,
	98	) -> HRESULT,
	99	fn GetRestoreMethod(
	100	pMethod: *mut VSS_RESTOREMETHOD_ENUM,
	101	pbstrService: *mut BSTR,
	102	pbstrUserProcedure: *mut BSTR,
	103	pwriterRestore: *mut VSS_WRITERRESTORE_ENUM,
	104	pbRebootRequired: *mut bool,
	105	pcMappings: *mut UINT,
	106	) -> HRESULT,
	107	fn GetAlternateLocationMapping(
	108	iMapping: UINT,
	109	ppFiledesc: mut mut IVssWMFiledesc,
	110	) -> HRESULT,
	111	fn GetBackupSchema(
	112	pdwSchemaMask: *mut DWORD,
	113	) -> HRESULT,
	114	fn GetDocument(
	115	pDoc: *mut c_void,
	116	) -> HRESULT, //TODO IXMLDOMDocument,
	117	fn SaveAsXML(
	118	pbstrXML: *mut BSTR,
	119	) -> HRESULT,
	120	fn LoadFromXML(
	121	pbstrXML: *mut BSTR,
	122	) -> HRESULT,
0bf4aa26 XL	123	}}
0bf4aa26 XL	124	RIDL!{#[uuid(0x0c0e5ec0, 0xca44, 0x472b, 0xb7, 0x02, 0xe6, 0x52, 0xdb, 0x1c, 0x04, 0x51)]
ff7c6d11 XL	125	interface IVssExamineWriterMetadataEx(IVssExamineWriterMetadataExVtbl):
	126	IVssExamineWriterMetadata(IVssExamineWriterMetadataVtbl) {
	127	fn GetIdentityEx(
	128	pidInstance: *mut VSS_ID,
	129	pidWriter: *mut VSS_ID,
	130	pbstrWriterName: *mut BSTR,
	131	pbstrInstanceName: *mut BSTR,
	132	pUsage: *mut VSS_USAGE_TYPE,
	133	pSource: *mut VSS_SOURCE_TYPE,
	134	) -> HRESULT,
0bf4aa26 XL	135	}}
0bf4aa26 XL	136	RIDL!{#[uuid(0xce115780, 0xa611, 0x431b, 0xb5, 0x7f, 0xc3, 0x83, 0x03, 0xab, 0x6a, 0xee)]
ff7c6d11 XL	137	interface IVssExamineWriterMetadataEx2(IVssExamineWriterMetadataEx2Vtbl):
	138	IVssExamineWriterMetadataEx(IVssExamineWriterMetadataExVtbl) {
	139	fn GetVersion(
	140	pdwMajorVersion: *mut DWORD,
	141	pdwMinorVersion: *mut DWORD,
	142	) -> HRESULT,
	143	fn GetExcludeFromSnapshotCount(
	144	pcExcludedFromSnapshot: *mut UINT,
	145	) -> HRESULT,
	146	fn GetExcludeFromSnapshotFile(
	147	iFile: UINT,
	148	ppFiledesc: mut mut IVssWMFiledesc,
	149	) -> HRESULT,
0bf4aa26	150	}}
ff7c6d11 XL	151	#[repr(C)]
	152	pub struct IVssWriterComponentsExt {
	153	pub lpVtbl: *const IVssWriterComponentsExtVtbl,
	154	}
	155	#[repr(C)]
	156	pub struct IVssWriterComponentsExtVtbl {
	157	pub parent1: IVssWriterComponentsVtbl,
	158	pub parent2: IUnknownVtbl,
	159	}
0bf4aa26	160	RIDL!{#[uuid(0x665c1d5f, 0xc218, 0x414d, 0xa0, 0x5d, 0x7f, 0xef, 0x5f, 0x9d, 0x5c, 0x86)]
ff7c6d11 XL	161	interface IVssBackupComponents(IVssBackupComponentsVtbl): IUnknown(IUnknownVtbl) {
	162	fn GetWriterComponentsCount(
	163	pcComponents: *mut UINT,
	164	) -> HRESULT,
	165	fn GetWriterComponents(
	166	iWriter: UINT,
	167	ppWriter: mut mut IVssWriterComponentsExt,
	168	) -> HRESULT,
	169	fn InitializeForBackup(
	170	bstrXML: BSTR,
	171	) -> HRESULT,
	172	fn SetBackupState(
	173	bSelectComponents: bool,
	174	bBackupBootableSystemState: bool,
	175	backupType: VSS_BACKUP_TYPE,
	176	bPartialFileSupport: bool,
	177	) -> HRESULT,
	178	fn InitializeForRestore(
	179	bstrXML: BSTR,
	180	) -> HRESULT,
	181	fn SetRestoreState(
	182	restoreType: VSS_RESTORE_TYPE,
	183	) -> HRESULT,
	184	fn GatherWriterMetadata(
	185	pAsync: mut mut IVssAsync,
	186	) -> HRESULT,
	187	fn GetWriterMetadataCount(
	188	pcWriters: *mut UINT,
	189	) -> HRESULT,
	190	fn GetWriterMetadata(
	191	iWriter: UINT,
	192	pidInstance: *mut VSS_ID,
	193	ppMetadata: mut mut IVssExamineWriterMetadata,
	194	) -> HRESULT,
	195	fn FreeWriterMetadata() -> HRESULT,
	196	fn AddComponent(
	197	instanceId: VSS_ID,
	198	writerId: VSS_ID,
	199	ct: VSS_COMPONENT_TYPE,
	200	wszLogicalPath: LPCWSTR,
	201	wszComponentName: LPCWSTR,
	202	) -> HRESULT,
	203	fn PrepareForBackup(
	204	ppAsync: mut mut IVssAsync,
	205	) -> HRESULT,
	206	fn AbortBackup() -> HRESULT,
	207	fn GatherWriterStatus(
	208	ppAsync: mut mut IVssAsync,
	209	) -> HRESULT,
	210	fn GetWriterStatusCount(
	211	pcWriters: *mut UINT,
	212	) -> HRESULT,
	213	fn FreeWriterStatus() -> HRESULT,
	214	fn GetWriterStatus(
	215	iWriter: UINT,
	216	pidInstance: *mut VSS_ID,
	217	pidWriter: *mut VSS_ID,
	218	pbstrWriter: *mut BSTR,
	219	pnStatus: *mut VSS_WRITER_STATE,
	220	phResultFailure: *mut HRESULT,
	221	) -> HRESULT,
	222	fn SetBackupSucceeded(
	223	instanceId: VSS_ID,
	224	writerId: VSS_ID,
225	ct: VSS_COMPONENT_TYPE,
226	wszLogicalPath: LPCWSTR,
227	wszComponentName: LPCWSTR,
228	bSucceded: bool,
229	) -> HRESULT,
230	fn SetBackupOptions(
231	writerId: VSS_ID,
232	ct: VSS_COMPONENT_TYPE,
233	wszLogicalPath: LPCWSTR,
234	wszComponentName: LPCWSTR,
235	wszBackupOptions: LPCWSTR,
236	) -> HRESULT,
237	fn SetSelectedForRestore(
238	writerId: VSS_ID,
239	ct: VSS_COMPONENT_TYPE,
240	wszLogicalPath: LPCWSTR,
241	wszComponentName: LPCWSTR,
242	bSelectedForRestore: bool,
243	) -> HRESULT,
244	fn SetRestoreOptions(
245	writerId: VSS_ID,
246	ct: VSS_COMPONENT_TYPE,
247	wszLogicalPath: LPCWSTR,
248	wszComponentName: LPCWSTR,
249	wszRestoreOptions: LPCWSTR,
250	) -> HRESULT,
251	fn SetAdditionalRestores(
252	writerId: VSS_ID,
253	ct: VSS_COMPONENT_TYPE,
254	wszLogicalPath: LPCWSTR,
255	wszComponentName: LPCWSTR,
256	bAdditionalRestores: bool,
257	) -> HRESULT,
258	fn SetPreviousBackupStamp(
259	writerId: VSS_ID,
260	ct: VSS_COMPONENT_TYPE,
261	wszLogicalPath: LPCWSTR,
262	wszComponentName: LPCWSTR,
263	wszPreviousBackupStamp: LPCWSTR,
264	) -> HRESULT,
265	fn SaveAsXML(
266	pbstrXML: *mut BSTR,
267	) -> HRESULT,
268	fn BackupComplete(
269	ppAsync: mut mut IVssAsync,
270	) -> HRESULT,
271	fn AddAlternativeLocationMapping(
272	writerId: VSS_ID,
273	ct: VSS_COMPONENT_TYPE,
274	wszLogicalPath: LPCWSTR,
275	wszComponentName: LPCWSTR,
276	wszPath: LPCWSTR,
277	wszFilespec: LPCWSTR,
278	bRecursive: bool,
279	wszDestination: LPCWSTR,
280	) -> HRESULT,
281	fn AddRestoreSubcomponent(
282	writerId: VSS_ID,
283	ct: VSS_COMPONENT_TYPE,
284	wszLogicalPath: LPCWSTR,
285	wszComponentName: LPCWSTR,
286	wszSubComponentLogicalPath: LPCWSTR,
287	wszSubComponentName: LPCWSTR,
288	bRepair: bool,
289	) -> HRESULT,
290	fn SetFileRestoreStatus(
291	writerId: VSS_ID,
292	ct: VSS_COMPONENT_TYPE,
293	wszLogicalPath: LPCWSTR,
294	wszComponentName: LPCWSTR,
295	status: VSS_FILE_RESTORE_STATUS,
296	) -> HRESULT,
297	fn AddNewTarget(
298	writerId: VSS_ID,
299	ct: VSS_COMPONENT_TYPE,
300	wszLogicalPath: LPCWSTR,
301	wszComponentName: LPCWSTR,
302	wszPath: LPCWSTR,
303	wszFileName: LPCWSTR,
304	bRecursive: bool,
305	wszAlternatePath: LPCWSTR,
306	) -> HRESULT,
307	fn SetRangesFilePath(
308	writerId: VSS_ID,
309	ct: VSS_COMPONENT_TYPE,
310	wszLogicalPath: LPCWSTR,
311	wszComponentName: LPCWSTR,
312	iPartialFile: UINT,
313	wszRangesFile: LPCWSTR,
314	) -> HRESULT,
315	fn PreRestore(
316	ppAsync: mut mut IVssAsync,
317	) -> HRESULT,
318	fn PostRestore(
319	ppAsync: mut mut IVssAsync,
320	) -> HRESULT,
321	fn SetContext(
322	lContext: LONG,
323	) -> HRESULT,
324	fn StartSnapshotSet(
325	pSnapshotSetId: *mut VSS_ID,
326	) -> HRESULT,
327	fn AddToSnapshotSet(
328	pwszVolumeName: VSS_PWSZ,
329	ProviderId: VSS_ID,
330	pidSnapshot: *mut VSS_ID,
331	) -> HRESULT,
332	fn DoSnapshotSet(
333	ppAsync: mut mut IVssAsync,
334	) -> HRESULT,
335	fn DeleteSnapshots(
336	SourceObjectId: VSS_ID,
337	eSourceObjectType: VSS_OBJECT_TYPE,
338	bForceDelete: BOOL,
339	plDeletedSnapshots: *mut LONG,
340	pNondeletedSnapshotID: *mut VSS_ID,
341	) -> HRESULT,
342	fn ImportSnapshots(
343	ppAsync: mut mut IVssAsync,
344	) -> HRESULT,
345	fn BreakSnapshotSet(
346	SnapshotSetId: VSS_ID,
347	) -> HRESULT,
348	fn GetSnapshotProperties(
349	SnapshotId: VSS_ID,
350	pProp: *mut VSS_SNAPSHOT_PROP,
351	) -> HRESULT,
352	fn Query(
353	QueriedObjectId: VSS_ID,
354	eQueriedObjectType: VSS_OBJECT_TYPE,
355	eReturnedObjectsType: VSS_OBJECT_TYPE,
356	ppEnum: mut mut IVssEnumObject,
357	) -> HRESULT,
358	fn IsVolumeSupported(
359	ProviderId: VSS_ID,
360	pwszVolumeName: VSS_PWSZ,
361	pbSupportedByThisProvider: *mut BOOL,
362	) -> HRESULT,
363	fn DisableWriterClasses(
364	rgWriterClassId: *const VSS_ID,
365	cClassId: UINT,
366	) -> HRESULT,
367	fn EnableWriterClasses(
368	rgWriterClassId: *const VSS_ID,
369	cClassId: UINT,
370	) -> HRESULT,
371	fn DisableWriterInstances(
372	rgWriterInstanceId: *const VSS_ID,
373	cInstanceId: UINT,
374	) -> HRESULT,
375	fn ExposeSnapshot(
376	SnapshotId: VSS_ID,
377	wszPathFromRoot: VSS_PWSZ,
378	lAttributes: LONG,
379	wszExpose: VSS_PWSZ,
380	pwszExposed: VSS_PWSZ,
381	) -> HRESULT,
382	fn RevertToSnapshot(
383	SnapshotId: VSS_ID,
384	bForceDismount: BOOL,
385	) -> HRESULT,
386	fn QueryRevertStatus(
387	pwszVolume: VSS_PWSZ,
388	ppAsync: mut mut IVssAsync,
389	) -> HRESULT,
0bf4aa26 XL	390	}}
0bf4aa26 XL	391	RIDL!{#[uuid(0x963f03ad, 0x9e4c, 0x4a34, 0xac, 0x15, 0xe4, 0xb6, 0x17, 0x4e, 0x50, 0x36)]
ff7c6d11 XL	392	interface IVssBackupComponentsEx(IVssBackupComponentsExVtbl):
	393	IVssBackupComponents(IVssBackupComponentsVtbl) {
	394	fn GetWriterMetadataEx(
	395	iWriter: UINT,
	396	pidInstance: *mut VSS_ID,
	397	ppMetadata: mut mut IVssExamineWriterMetadataEx,
	398	) -> HRESULT,
	399	fn SetSelectedForRestoreEx(
	400	writerId: VSS_ID,
	401	ct: VSS_COMPONENT_TYPE,
	402	wszLogicalPath: LPCWSTR,
	403	wszComponentName: LPCWSTR,
	404	bSelectedForRestore: bool,
	405	instanceId: VSS_ID,
	406	) -> HRESULT,
0bf4aa26 XL	407	}}
0bf4aa26 XL	408	RIDL!{#[uuid(0xacfe2b3a, 0x22c9, 0x4ef8, 0xbd, 0x03, 0x2f, 0x9c, 0xa2, 0x30, 0x08, 0x4e)]
ff7c6d11 XL	409	interface IVssBackupComponentsEx2(IVssBackupComponentsEx2Vtbl):
	410	IVssBackupComponentsEx(IVssBackupComponentsExVtbl) {
	411	fn UnexposeSnapshot(
	412	snapshotId: VSS_ID,
	413	) -> HRESULT,
	414	fn SetAuthoritativeRestore(
	415	writerId: VSS_ID,
	416	ct: VSS_COMPONENT_TYPE,
	417	wszLogicalPath: LPCWSTR,
	418	wszComponentName: LPCWSTR,
	419	bAuth: bool,
	420	) -> HRESULT,
	421	fn SetRollForward(
	422	writerId: VSS_ID,
	423	ct: VSS_COMPONENT_TYPE,
	424	wszLogicalPath: LPCWSTR,
	425	wszComponentName: LPCWSTR,
	426	rollType: VSS_ROLLFORWARD_TYPE,
	427	wszRollForwardPoint: LPCWSTR,
	428	) -> HRESULT,
	429	fn SetRestoreName(
	430	writerId: VSS_ID,
	431	ct: VSS_COMPONENT_TYPE,
	432	wszLogicalPath: LPCWSTR,
	433	wszComponentName: LPCWSTR,
	434	wszRestoreName: LPCWSTR,
	435	) -> HRESULT,
	436	fn BreakSnapshotSetEx(
	437	SnapshotSetID: VSS_ID,
	438	dwBreakFlags: DWORD,
	439	ppAsync: mut mut IVssAsync,
	440	) -> HRESULT,
	441	fn PreFastRecovery(
	442	SnapshotSetID: VSS_ID,
	443	dwPreFastRecoveryFlags: DWORD,
	444	ppAsync: mut mut IVssAsync,
	445	) -> HRESULT,
	446	fn FastRecovery(
	447	SnapshotSetID: VSS_ID,
	448	dwFastRecoveryFlags: DWORD,
	449	ppAsync: mut mut IVssAsync,
	450	) -> HRESULT,
0bf4aa26 XL	451	}}
0bf4aa26 XL	452	RIDL!{#[uuid(0xc191bfbc, 0xb602, 0x4675, 0x8b, 0xd1, 0x67, 0xd6, 0x42, 0xf5, 0x29, 0xd5)]
ff7c6d11 XL	453	interface IVssBackupComponentsEx3(IVssBackupComponentsEx3Vtbl):
	454	IVssBackupComponentsEx2(IVssBackupComponentsEx2Vtbl) {
	455	fn GetWriterStatusEx(
	456	iWriter: UINT,
	457	pidInstance: *mut VSS_ID,
	458	pidWriter: *mut VSS_ID,
	459	pbstrWriter: *mut BSTR,
	460	pnStatus: *mut VSS_WRITER_STATE,
	461	phrFailureWriter: *mut HRESULT,
	462	phrApplication: *mut HRESULT,
	463	pbstrApplicationMessage: *mut BSTR,
	464	) -> HRESULT,
	465	fn AddSnapshotToRecoverySet(
	466	snapshotId: VSS_ID,
	467	dwFlags: DWORD,
	468	pwszDestinationVolume: VSS_PWSZ,
	469	) -> HRESULT,
	470	fn RecoverSet(
	471	dwFlags: DWORD,
	472	ppAsync: mut mut IVssAsync,
	473	) -> HRESULT,
	474	fn GetSessionId(
	475	idSession: *mut VSS_ID,
	476	) -> HRESULT,
0bf4aa26 XL	477	}}
0bf4aa26 XL	478	RIDL!{#[uuid(0xf434c2fd, 0xb553, 0x4961, 0xa9, 0xf9, 0xa8, 0xe9, 0x0b, 0x67, 0x3e, 0x53)]
ff7c6d11 XL	479	interface IVssBackupComponentsEx4(IVssBackupComponentsEx4Vtbl):
	480	IVssBackupComponentsEx3(IVssBackupComponentsEx3Vtbl) {
	481	fn GetRootAndLogicalPrefixPaths(
	482	pwszFilePath: VSS_PWSZ,
	483	ppwszRootPath: *mut VSS_PWSZ,
	484	ppwszLogicalPrefix: *mut VSS_PWSZ,
	485	bNormalizeFQDNforRootPath: BOOL,
	486	) -> HRESULT,
0bf4aa26	487	}}
ff7c6d11 XL	488	pub const VSS_SW_BOOTABLE_STATE: DWORD = 1;
	489	extern "system" {
	490	#[link_name="CreateVssBackupComponentsInternal"]
	491	pub fn CreateVssBackupComponents(
	492	ppBackup: mut mut IVssBackupComponents,
	493	) -> HRESULT;
	494	#[link_name="CreateVssExamineWriterMetadataInternal"]
	495	pub fn CreateVssExamineWriterMetadata(
	496	bstrXML: BSTR,
	497	ppMetadata: mut mut IVssExamineWriterMetadata,
	498	) -> HRESULT;
	499	#[link_name="IsVolumeSnapshottedInternal"]
	500	pub fn IsVolumeSnapshotted(
	501	pwszVolumeName: VSS_PWSZ,
	502	pbSnapshotsPresent: *mut BOOL,
	503	plSnapshotCapability: *mut LONG,
	504	) -> HRESULT;
	505	#[link_name="VssFreeSnapshotPropertiesInternal"]
	506	pub fn VssFreeSnapshotProperties(
	507	pProp: *mut VSS_SNAPSHOT_PROP,
	508	);
	509	#[link_name="GetProviderMgmtInterfaceInternal"]
	510	pub fn GetProviderMgmtInterface(
	511	ProviderId: VSS_ID,
	512	InterfaceId: IID,
	513	ppItf: mut mut IUnknown,
	514	) -> HRESULT;
	515	#[link_name="ShouldBlockRevertInternal"]
	516	pub fn ShouldBlockRevert(
	517	wszVolumeName: LPCWSTR,
	518	pbBlock: *mut bool,
	519	) -> HRESULT;
	520	}