//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (83)
//--------------------------------------------------------------------------------
pub const VSS_ASSOC_NO_MAX_SPACE = @as(i32, -1);
pub const VSS_ASSOC_REMOVE = @as(u32, 0);
pub const VSS_E_BAD_STATE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212543));
pub const VSS_E_UNEXPECTED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212542));
pub const VSS_E_PROVIDER_ALREADY_REGISTERED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212541));
pub const VSS_E_PROVIDER_NOT_REGISTERED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212540));
pub const VSS_E_PROVIDER_VETO = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212538));
pub const VSS_E_PROVIDER_IN_USE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212537));
pub const VSS_E_OBJECT_NOT_FOUND = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212536));
pub const VSS_S_ASYNC_PENDING = @import("../zig.zig").typedConst(HRESULT, @as(i32, 271113));
pub const VSS_S_ASYNC_FINISHED = @import("../zig.zig").typedConst(HRESULT, @as(i32, 271114));
pub const VSS_S_ASYNC_CANCELLED = @import("../zig.zig").typedConst(HRESULT, @as(i32, 271115));
pub const VSS_E_VOLUME_NOT_SUPPORTED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212532));
pub const VSS_E_VOLUME_NOT_SUPPORTED_BY_PROVIDER = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212530));
pub const VSS_E_OBJECT_ALREADY_EXISTS = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212531));
pub const VSS_E_UNEXPECTED_PROVIDER_ERROR = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212529));
pub const VSS_E_CORRUPT_XML_DOCUMENT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212528));
pub const VSS_E_INVALID_XML_DOCUMENT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212527));
pub const VSS_E_MAXIMUM_NUMBER_OF_VOLUMES_REACHED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212526));
pub const VSS_E_FLUSH_WRITES_TIMEOUT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212525));
pub const VSS_E_HOLD_WRITES_TIMEOUT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212524));
pub const VSS_E_UNEXPECTED_WRITER_ERROR = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212523));
pub const VSS_E_SNAPSHOT_SET_IN_PROGRESS = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212522));
pub const VSS_E_MAXIMUM_NUMBER_OF_SNAPSHOTS_REACHED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212521));
pub const VSS_E_WRITER_INFRASTRUCTURE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212520));
pub const VSS_E_WRITER_NOT_RESPONDING = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212519));
pub const VSS_E_WRITER_ALREADY_SUBSCRIBED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212518));
pub const VSS_E_UNSUPPORTED_CONTEXT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212517));
pub const VSS_E_VOLUME_IN_USE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212515));
pub const VSS_E_MAXIMUM_DIFFAREA_ASSOCIATIONS_REACHED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212514));
pub const VSS_E_INSUFFICIENT_STORAGE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212513));
pub const VSS_E_NO_SNAPSHOTS_IMPORTED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212512));
pub const VSS_S_SOME_SNAPSHOTS_NOT_IMPORTED = @import("../zig.zig").typedConst(HRESULT, @as(i32, 271137));
pub const VSS_E_SOME_SNAPSHOTS_NOT_IMPORTED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212511));
pub const VSS_E_MAXIMUM_NUMBER_OF_REMOTE_MACHINES_REACHED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212510));
pub const VSS_E_REMOTE_SERVER_UNAVAILABLE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212509));
pub const VSS_E_REMOTE_SERVER_UNSUPPORTED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212508));
pub const VSS_E_REVERT_IN_PROGRESS = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212507));
pub const VSS_E_REVERT_VOLUME_LOST = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212506));
pub const VSS_E_REBOOT_REQUIRED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212505));
pub const VSS_E_TRANSACTION_FREEZE_TIMEOUT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212504));
pub const VSS_E_TRANSACTION_THAW_TIMEOUT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212503));
pub const VSS_E_VOLUME_NOT_LOCAL = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212499));
pub const VSS_E_CLUSTER_TIMEOUT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212498));
pub const VSS_E_WRITERERROR_INCONSISTENTSNAPSHOT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212304));
pub const VSS_E_WRITERERROR_OUTOFRESOURCES = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212303));
pub const VSS_E_WRITERERROR_TIMEOUT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212302));
pub const VSS_E_WRITERERROR_RETRYABLE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212301));
pub const VSS_E_WRITERERROR_NONRETRYABLE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212300));
pub const VSS_E_WRITERERROR_RECOVERY_FAILED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212299));
pub const VSS_E_BREAK_REVERT_ID_FAILED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212298));
pub const VSS_E_LEGACY_PROVIDER = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212297));
pub const VSS_E_MISSING_DISK = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212296));
pub const VSS_E_MISSING_HIDDEN_VOLUME = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212295));
pub const VSS_E_MISSING_VOLUME = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212294));
pub const VSS_E_AUTORECOVERY_FAILED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212293));
pub const VSS_E_DYNAMIC_DISK_ERROR = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212292));
pub const VSS_E_NONTRANSPORTABLE_BCD = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212291));
pub const VSS_E_CANNOT_REVERT_DISKID = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212290));
pub const VSS_E_RESYNC_IN_PROGRESS = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212289));
pub const VSS_E_CLUSTER_ERROR = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212288));
pub const VSS_E_UNSELECTED_VOLUME = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212502));
pub const VSS_E_SNAPSHOT_NOT_IN_SET = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212501));
pub const VSS_E_NESTED_VOLUME_LIMIT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212500));
pub const VSS_E_NOT_SUPPORTED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212497));
pub const VSS_E_WRITERERROR_PARTIAL_FAILURE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212490));
pub const VSS_E_ASRERROR_DISK_ASSIGNMENT_FAILED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212287));
pub const VSS_E_ASRERROR_DISK_RECREATION_FAILED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212286));
pub const VSS_E_ASRERROR_NO_ARCPATH = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212285));
pub const VSS_E_ASRERROR_MISSING_DYNDISK = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212284));
pub const VSS_E_ASRERROR_SHARED_CRIDISK = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212283));
pub const VSS_E_ASRERROR_DATADISK_RDISK0 = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212282));
pub const VSS_E_ASRERROR_RDISK0_TOOSMALL = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212281));
pub const VSS_E_ASRERROR_CRITICAL_DISKS_TOO_SMALL = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212280));
pub const VSS_E_WRITER_STATUS_NOT_AVAILABLE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212279));
pub const VSS_E_ASRERROR_DYNAMIC_VHD_NOT_SUPPORTED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212278));
pub const VSS_E_CRITICAL_VOLUME_ON_INVALID_DISK = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212271));
pub const VSS_E_ASRERROR_RDISK_FOR_SYSTEM_DISK_NOT_FOUND = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212270));
pub const VSS_E_ASRERROR_NO_PHYSICAL_DISK_AVAILABLE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212269));
pub const VSS_E_ASRERROR_FIXED_PHYSICAL_DISK_AVAILABLE_AFTER_DISK_EXCLUSION = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212268));
pub const VSS_E_ASRERROR_CRITICAL_DISK_CANNOT_BE_EXCLUDED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212267));
pub const VSS_E_ASRERROR_SYSTEM_PARTITION_HIDDEN = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212266));
pub const VSS_E_FSS_TIMEOUT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147212265));

//--------------------------------------------------------------------------------
// Section: Types (69)
//--------------------------------------------------------------------------------
pub const VSS_OBJECT_TYPE = enum(i32) {
    UNKNOWN = 0,
    NONE = 1,
    SNAPSHOT_SET = 2,
    SNAPSHOT = 3,
    PROVIDER = 4,
    TYPE_COUNT = 5,
};
pub const VSS_OBJECT_UNKNOWN = VSS_OBJECT_TYPE.UNKNOWN;
pub const VSS_OBJECT_NONE = VSS_OBJECT_TYPE.NONE;
pub const VSS_OBJECT_SNAPSHOT_SET = VSS_OBJECT_TYPE.SNAPSHOT_SET;
pub const VSS_OBJECT_SNAPSHOT = VSS_OBJECT_TYPE.SNAPSHOT;
pub const VSS_OBJECT_PROVIDER = VSS_OBJECT_TYPE.PROVIDER;
pub const VSS_OBJECT_TYPE_COUNT = VSS_OBJECT_TYPE.TYPE_COUNT;

pub const VSS_SNAPSHOT_STATE = enum(i32) {
    UNKNOWN = 0,
    PREPARING = 1,
    PROCESSING_PREPARE = 2,
    PREPARED = 3,
    PROCESSING_PRECOMMIT = 4,
    PRECOMMITTED = 5,
    PROCESSING_COMMIT = 6,
    COMMITTED = 7,
    PROCESSING_POSTCOMMIT = 8,
    PROCESSING_PREFINALCOMMIT = 9,
    PREFINALCOMMITTED = 10,
    PROCESSING_POSTFINALCOMMIT = 11,
    CREATED = 12,
    ABORTED = 13,
    DELETED = 14,
    POSTCOMMITTED = 15,
    COUNT = 16,
};
pub const VSS_SS_UNKNOWN = VSS_SNAPSHOT_STATE.UNKNOWN;
pub const VSS_SS_PREPARING = VSS_SNAPSHOT_STATE.PREPARING;
pub const VSS_SS_PROCESSING_PREPARE = VSS_SNAPSHOT_STATE.PROCESSING_PREPARE;
pub const VSS_SS_PREPARED = VSS_SNAPSHOT_STATE.PREPARED;
pub const VSS_SS_PROCESSING_PRECOMMIT = VSS_SNAPSHOT_STATE.PROCESSING_PRECOMMIT;
pub const VSS_SS_PRECOMMITTED = VSS_SNAPSHOT_STATE.PRECOMMITTED;
pub const VSS_SS_PROCESSING_COMMIT = VSS_SNAPSHOT_STATE.PROCESSING_COMMIT;
pub const VSS_SS_COMMITTED = VSS_SNAPSHOT_STATE.COMMITTED;
pub const VSS_SS_PROCESSING_POSTCOMMIT = VSS_SNAPSHOT_STATE.PROCESSING_POSTCOMMIT;
pub const VSS_SS_PROCESSING_PREFINALCOMMIT = VSS_SNAPSHOT_STATE.PROCESSING_PREFINALCOMMIT;
pub const VSS_SS_PREFINALCOMMITTED = VSS_SNAPSHOT_STATE.PREFINALCOMMITTED;
pub const VSS_SS_PROCESSING_POSTFINALCOMMIT = VSS_SNAPSHOT_STATE.PROCESSING_POSTFINALCOMMIT;
pub const VSS_SS_CREATED = VSS_SNAPSHOT_STATE.CREATED;
pub const VSS_SS_ABORTED = VSS_SNAPSHOT_STATE.ABORTED;
pub const VSS_SS_DELETED = VSS_SNAPSHOT_STATE.DELETED;
pub const VSS_SS_POSTCOMMITTED = VSS_SNAPSHOT_STATE.POSTCOMMITTED;
pub const VSS_SS_COUNT = VSS_SNAPSHOT_STATE.COUNT;

pub const VSS_VOLUME_SNAPSHOT_ATTRIBUTES = enum(i32) {
    PERSISTENT = 1,
    NO_AUTORECOVERY = 2,
    CLIENT_ACCESSIBLE = 4,
    NO_AUTO_RELEASE = 8,
    NO_WRITERS = 16,
    TRANSPORTABLE = 32,
    NOT_SURFACED = 64,
    NOT_TRANSACTED = 128,
    HARDWARE_ASSISTED = 65536,
    DIFFERENTIAL = 131072,
    PLEX = 262144,
    IMPORTED = 524288,
    EXPOSED_LOCALLY = 1048576,
    EXPOSED_REMOTELY = 2097152,
    AUTORECOVER = 4194304,
    ROLLBACK_RECOVERY = 8388608,
    DELAYED_POSTSNAPSHOT = 16777216,
    TXF_RECOVERY = 33554432,
    FILE_SHARE = 67108864,
};
pub const VSS_VOLSNAP_ATTR_PERSISTENT = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.PERSISTENT;
pub const VSS_VOLSNAP_ATTR_NO_AUTORECOVERY = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.NO_AUTORECOVERY;
pub const VSS_VOLSNAP_ATTR_CLIENT_ACCESSIBLE = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.CLIENT_ACCESSIBLE;
pub const VSS_VOLSNAP_ATTR_NO_AUTO_RELEASE = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.NO_AUTO_RELEASE;
pub const VSS_VOLSNAP_ATTR_NO_WRITERS = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.NO_WRITERS;
pub const VSS_VOLSNAP_ATTR_TRANSPORTABLE = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.TRANSPORTABLE;
pub const VSS_VOLSNAP_ATTR_NOT_SURFACED = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.NOT_SURFACED;
pub const VSS_VOLSNAP_ATTR_NOT_TRANSACTED = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.NOT_TRANSACTED;
pub const VSS_VOLSNAP_ATTR_HARDWARE_ASSISTED = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.HARDWARE_ASSISTED;
pub const VSS_VOLSNAP_ATTR_DIFFERENTIAL = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.DIFFERENTIAL;
pub const VSS_VOLSNAP_ATTR_PLEX = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.PLEX;
pub const VSS_VOLSNAP_ATTR_IMPORTED = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.IMPORTED;
pub const VSS_VOLSNAP_ATTR_EXPOSED_LOCALLY = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.EXPOSED_LOCALLY;
pub const VSS_VOLSNAP_ATTR_EXPOSED_REMOTELY = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.EXPOSED_REMOTELY;
pub const VSS_VOLSNAP_ATTR_AUTORECOVER = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.AUTORECOVER;
pub const VSS_VOLSNAP_ATTR_ROLLBACK_RECOVERY = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.ROLLBACK_RECOVERY;
pub const VSS_VOLSNAP_ATTR_DELAYED_POSTSNAPSHOT = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.DELAYED_POSTSNAPSHOT;
pub const VSS_VOLSNAP_ATTR_TXF_RECOVERY = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.TXF_RECOVERY;
pub const VSS_VOLSNAP_ATTR_FILE_SHARE = VSS_VOLUME_SNAPSHOT_ATTRIBUTES.FILE_SHARE;

pub const VSS_SNAPSHOT_CONTEXT = enum(i32) {
    BACKUP = 0,
    FILE_SHARE_BACKUP = 16,
    NAS_ROLLBACK = 25,
    APP_ROLLBACK = 9,
    CLIENT_ACCESSIBLE = 29,
    CLIENT_ACCESSIBLE_WRITERS = 13,
    ALL = -1,
};
pub const VSS_CTX_BACKUP = VSS_SNAPSHOT_CONTEXT.BACKUP;
pub const VSS_CTX_FILE_SHARE_BACKUP = VSS_SNAPSHOT_CONTEXT.FILE_SHARE_BACKUP;
pub const VSS_CTX_NAS_ROLLBACK = VSS_SNAPSHOT_CONTEXT.NAS_ROLLBACK;
pub const VSS_CTX_APP_ROLLBACK = VSS_SNAPSHOT_CONTEXT.APP_ROLLBACK;
pub const VSS_CTX_CLIENT_ACCESSIBLE = VSS_SNAPSHOT_CONTEXT.CLIENT_ACCESSIBLE;
pub const VSS_CTX_CLIENT_ACCESSIBLE_WRITERS = VSS_SNAPSHOT_CONTEXT.CLIENT_ACCESSIBLE_WRITERS;
pub const VSS_CTX_ALL = VSS_SNAPSHOT_CONTEXT.ALL;

pub const VSS_PROVIDER_CAPABILITIES = enum(i32) {
    LEGACY = 1,
    COMPLIANT = 2,
    LUN_REPOINT = 4,
    LUN_RESYNC = 8,
    OFFLINE_CREATION = 16,
    MULTIPLE_IMPORT = 32,
    RECYCLING = 64,
    PLEX = 128,
    DIFFERENTIAL = 256,
    CLUSTERED = 512,
};
pub const VSS_PRV_CAPABILITY_LEGACY = VSS_PROVIDER_CAPABILITIES.LEGACY;
pub const VSS_PRV_CAPABILITY_COMPLIANT = VSS_PROVIDER_CAPABILITIES.COMPLIANT;
pub const VSS_PRV_CAPABILITY_LUN_REPOINT = VSS_PROVIDER_CAPABILITIES.LUN_REPOINT;
pub const VSS_PRV_CAPABILITY_LUN_RESYNC = VSS_PROVIDER_CAPABILITIES.LUN_RESYNC;
pub const VSS_PRV_CAPABILITY_OFFLINE_CREATION = VSS_PROVIDER_CAPABILITIES.OFFLINE_CREATION;
pub const VSS_PRV_CAPABILITY_MULTIPLE_IMPORT = VSS_PROVIDER_CAPABILITIES.MULTIPLE_IMPORT;
pub const VSS_PRV_CAPABILITY_RECYCLING = VSS_PROVIDER_CAPABILITIES.RECYCLING;
pub const VSS_PRV_CAPABILITY_PLEX = VSS_PROVIDER_CAPABILITIES.PLEX;
pub const VSS_PRV_CAPABILITY_DIFFERENTIAL = VSS_PROVIDER_CAPABILITIES.DIFFERENTIAL;
pub const VSS_PRV_CAPABILITY_CLUSTERED = VSS_PROVIDER_CAPABILITIES.CLUSTERED;

pub const VSS_HARDWARE_OPTIONS = enum(i32) {
    BREAKEX_FLAG_MASK_LUNS = 1,
    BREAKEX_FLAG_MAKE_READ_WRITE = 2,
    BREAKEX_FLAG_REVERT_IDENTITY_ALL = 4,
    BREAKEX_FLAG_REVERT_IDENTITY_NONE = 8,
    ONLUNSTATECHANGE_NOTIFY_READ_WRITE = 256,
    ONLUNSTATECHANGE_NOTIFY_LUN_PRE_RECOVERY = 512,
    ONLUNSTATECHANGE_NOTIFY_LUN_POST_RECOVERY = 1024,
    ONLUNSTATECHANGE_DO_MASK_LUNS = 2048,
};
pub const VSS_BREAKEX_FLAG_MASK_LUNS = VSS_HARDWARE_OPTIONS.BREAKEX_FLAG_MASK_LUNS;
pub const VSS_BREAKEX_FLAG_MAKE_READ_WRITE = VSS_HARDWARE_OPTIONS.BREAKEX_FLAG_MAKE_READ_WRITE;
pub const VSS_BREAKEX_FLAG_REVERT_IDENTITY_ALL = VSS_HARDWARE_OPTIONS.BREAKEX_FLAG_REVERT_IDENTITY_ALL;
pub const VSS_BREAKEX_FLAG_REVERT_IDENTITY_NONE = VSS_HARDWARE_OPTIONS.BREAKEX_FLAG_REVERT_IDENTITY_NONE;
pub const VSS_ONLUNSTATECHANGE_NOTIFY_READ_WRITE = VSS_HARDWARE_OPTIONS.ONLUNSTATECHANGE_NOTIFY_READ_WRITE;
pub const VSS_ONLUNSTATECHANGE_NOTIFY_LUN_PRE_RECOVERY = VSS_HARDWARE_OPTIONS.ONLUNSTATECHANGE_NOTIFY_LUN_PRE_RECOVERY;
pub const VSS_ONLUNSTATECHANGE_NOTIFY_LUN_POST_RECOVERY = VSS_HARDWARE_OPTIONS.ONLUNSTATECHANGE_NOTIFY_LUN_POST_RECOVERY;
pub const VSS_ONLUNSTATECHANGE_DO_MASK_LUNS = VSS_HARDWARE_OPTIONS.ONLUNSTATECHANGE_DO_MASK_LUNS;

pub const VSS_RECOVERY_OPTIONS = enum(i32) {
    REVERT_IDENTITY_ALL = 256,
    NO_VOLUME_CHECK = 512,
};
pub const VSS_RECOVERY_REVERT_IDENTITY_ALL = VSS_RECOVERY_OPTIONS.REVERT_IDENTITY_ALL;
pub const VSS_RECOVERY_NO_VOLUME_CHECK = VSS_RECOVERY_OPTIONS.NO_VOLUME_CHECK;

pub const VSS_WRITER_STATE = enum(i32) {
    UNKNOWN = 0,
    STABLE = 1,
    WAITING_FOR_FREEZE = 2,
    WAITING_FOR_THAW = 3,
    WAITING_FOR_POST_SNAPSHOT = 4,
    WAITING_FOR_BACKUP_COMPLETE = 5,
    FAILED_AT_IDENTIFY = 6,
    FAILED_AT_PREPARE_BACKUP = 7,
    FAILED_AT_PREPARE_SNAPSHOT = 8,
    FAILED_AT_FREEZE = 9,
    FAILED_AT_THAW = 10,
    FAILED_AT_POST_SNAPSHOT = 11,
    FAILED_AT_BACKUP_COMPLETE = 12,
    FAILED_AT_PRE_RESTORE = 13,
    FAILED_AT_POST_RESTORE = 14,
    FAILED_AT_BACKUPSHUTDOWN = 15,
    COUNT = 16,
};
pub const VSS_WS_UNKNOWN = VSS_WRITER_STATE.UNKNOWN;
pub const VSS_WS_STABLE = VSS_WRITER_STATE.STABLE;
pub const VSS_WS_WAITING_FOR_FREEZE = VSS_WRITER_STATE.WAITING_FOR_FREEZE;
pub const VSS_WS_WAITING_FOR_THAW = VSS_WRITER_STATE.WAITING_FOR_THAW;
pub const VSS_WS_WAITING_FOR_POST_SNAPSHOT = VSS_WRITER_STATE.WAITING_FOR_POST_SNAPSHOT;
pub const VSS_WS_WAITING_FOR_BACKUP_COMPLETE = VSS_WRITER_STATE.WAITING_FOR_BACKUP_COMPLETE;
pub const VSS_WS_FAILED_AT_IDENTIFY = VSS_WRITER_STATE.FAILED_AT_IDENTIFY;
pub const VSS_WS_FAILED_AT_PREPARE_BACKUP = VSS_WRITER_STATE.FAILED_AT_PREPARE_BACKUP;
pub const VSS_WS_FAILED_AT_PREPARE_SNAPSHOT = VSS_WRITER_STATE.FAILED_AT_PREPARE_SNAPSHOT;
pub const VSS_WS_FAILED_AT_FREEZE = VSS_WRITER_STATE.FAILED_AT_FREEZE;
pub const VSS_WS_FAILED_AT_THAW = VSS_WRITER_STATE.FAILED_AT_THAW;
pub const VSS_WS_FAILED_AT_POST_SNAPSHOT = VSS_WRITER_STATE.FAILED_AT_POST_SNAPSHOT;
pub const VSS_WS_FAILED_AT_BACKUP_COMPLETE = VSS_WRITER_STATE.FAILED_AT_BACKUP_COMPLETE;
pub const VSS_WS_FAILED_AT_PRE_RESTORE = VSS_WRITER_STATE.FAILED_AT_PRE_RESTORE;
pub const VSS_WS_FAILED_AT_POST_RESTORE = VSS_WRITER_STATE.FAILED_AT_POST_RESTORE;
pub const VSS_WS_FAILED_AT_BACKUPSHUTDOWN = VSS_WRITER_STATE.FAILED_AT_BACKUPSHUTDOWN;
pub const VSS_WS_COUNT = VSS_WRITER_STATE.COUNT;

pub const VSS_BACKUP_TYPE = enum(i32) {
    UNDEFINED = 0,
    FULL = 1,
    INCREMENTAL = 2,
    DIFFERENTIAL = 3,
    LOG = 4,
    COPY = 5,
    OTHER = 6,
};
pub const VSS_BT_UNDEFINED = VSS_BACKUP_TYPE.UNDEFINED;
pub const VSS_BT_FULL = VSS_BACKUP_TYPE.FULL;
pub const VSS_BT_INCREMENTAL = VSS_BACKUP_TYPE.INCREMENTAL;
pub const VSS_BT_DIFFERENTIAL = VSS_BACKUP_TYPE.DIFFERENTIAL;
pub const VSS_BT_LOG = VSS_BACKUP_TYPE.LOG;
pub const VSS_BT_COPY = VSS_BACKUP_TYPE.COPY;
pub const VSS_BT_OTHER = VSS_BACKUP_TYPE.OTHER;

pub const VSS_RESTORE_TYPE = enum(i32) {
    UNDEFINED = 0,
    BY_COPY = 1,
    IMPORT = 2,
    OTHER = 3,
};
pub const VSS_RTYPE_UNDEFINED = VSS_RESTORE_TYPE.UNDEFINED;
pub const VSS_RTYPE_BY_COPY = VSS_RESTORE_TYPE.BY_COPY;
pub const VSS_RTYPE_IMPORT = VSS_RESTORE_TYPE.IMPORT;
pub const VSS_RTYPE_OTHER = VSS_RESTORE_TYPE.OTHER;

pub const VSS_ROLLFORWARD_TYPE = enum(i32) {
    UNDEFINED = 0,
    NONE = 1,
    ALL = 2,
    PARTIAL = 3,
};
pub const VSS_RF_UNDEFINED = VSS_ROLLFORWARD_TYPE.UNDEFINED;
pub const VSS_RF_NONE = VSS_ROLLFORWARD_TYPE.NONE;
pub const VSS_RF_ALL = VSS_ROLLFORWARD_TYPE.ALL;
pub const VSS_RF_PARTIAL = VSS_ROLLFORWARD_TYPE.PARTIAL;

pub const VSS_PROVIDER_TYPE = enum(i32) {
    UNKNOWN = 0,
    SYSTEM = 1,
    SOFTWARE = 2,
    HARDWARE = 3,
    FILESHARE = 4,
};
pub const VSS_PROV_UNKNOWN = VSS_PROVIDER_TYPE.UNKNOWN;
pub const VSS_PROV_SYSTEM = VSS_PROVIDER_TYPE.SYSTEM;
pub const VSS_PROV_SOFTWARE = VSS_PROVIDER_TYPE.SOFTWARE;
pub const VSS_PROV_HARDWARE = VSS_PROVIDER_TYPE.HARDWARE;
pub const VSS_PROV_FILESHARE = VSS_PROVIDER_TYPE.FILESHARE;

pub const VSS_APPLICATION_LEVEL = enum(i32) {
    UNKNOWN = 0,
    SYSTEM = 1,
    BACK_END = 2,
    FRONT_END = 3,
    SYSTEM_RM = 4,
    AUTO = -1,
};
pub const VSS_APP_UNKNOWN = VSS_APPLICATION_LEVEL.UNKNOWN;
pub const VSS_APP_SYSTEM = VSS_APPLICATION_LEVEL.SYSTEM;
pub const VSS_APP_BACK_END = VSS_APPLICATION_LEVEL.BACK_END;
pub const VSS_APP_FRONT_END = VSS_APPLICATION_LEVEL.FRONT_END;
pub const VSS_APP_SYSTEM_RM = VSS_APPLICATION_LEVEL.SYSTEM_RM;
pub const VSS_APP_AUTO = VSS_APPLICATION_LEVEL.AUTO;

pub const VSS_SNAPSHOT_COMPATIBILITY = enum(i32) {
    DEFRAG = 1,
    CONTENTINDEX = 2,
};
pub const VSS_SC_DISABLE_DEFRAG = VSS_SNAPSHOT_COMPATIBILITY.DEFRAG;
pub const VSS_SC_DISABLE_CONTENTINDEX = VSS_SNAPSHOT_COMPATIBILITY.CONTENTINDEX;

pub const VSS_SNAPSHOT_PROPERTY_ID = enum(i32) {
    UNKNOWN = 0,
    SNAPSHOT_ID = 1,
    SNAPSHOT_SET_ID = 2,
    SNAPSHOTS_COUNT = 3,
    SNAPSHOT_DEVICE = 4,
    ORIGINAL_VOLUME = 5,
    ORIGINATING_MACHINE = 6,
    SERVICE_MACHINE = 7,
    EXPOSED_NAME = 8,
    EXPOSED_PATH = 9,
    PROVIDER_ID = 10,
    SNAPSHOT_ATTRIBUTES = 11,
    CREATION_TIMESTAMP = 12,
    STATUS = 13,
};
pub const VSS_SPROPID_UNKNOWN = VSS_SNAPSHOT_PROPERTY_ID.UNKNOWN;
pub const VSS_SPROPID_SNAPSHOT_ID = VSS_SNAPSHOT_PROPERTY_ID.SNAPSHOT_ID;
pub const VSS_SPROPID_SNAPSHOT_SET_ID = VSS_SNAPSHOT_PROPERTY_ID.SNAPSHOT_SET_ID;
pub const VSS_SPROPID_SNAPSHOTS_COUNT = VSS_SNAPSHOT_PROPERTY_ID.SNAPSHOTS_COUNT;
pub const VSS_SPROPID_SNAPSHOT_DEVICE = VSS_SNAPSHOT_PROPERTY_ID.SNAPSHOT_DEVICE;
pub const VSS_SPROPID_ORIGINAL_VOLUME = VSS_SNAPSHOT_PROPERTY_ID.ORIGINAL_VOLUME;
pub const VSS_SPROPID_ORIGINATING_MACHINE = VSS_SNAPSHOT_PROPERTY_ID.ORIGINATING_MACHINE;
pub const VSS_SPROPID_SERVICE_MACHINE = VSS_SNAPSHOT_PROPERTY_ID.SERVICE_MACHINE;
pub const VSS_SPROPID_EXPOSED_NAME = VSS_SNAPSHOT_PROPERTY_ID.EXPOSED_NAME;
pub const VSS_SPROPID_EXPOSED_PATH = VSS_SNAPSHOT_PROPERTY_ID.EXPOSED_PATH;
pub const VSS_SPROPID_PROVIDER_ID = VSS_SNAPSHOT_PROPERTY_ID.PROVIDER_ID;
pub const VSS_SPROPID_SNAPSHOT_ATTRIBUTES = VSS_SNAPSHOT_PROPERTY_ID.SNAPSHOT_ATTRIBUTES;
pub const VSS_SPROPID_CREATION_TIMESTAMP = VSS_SNAPSHOT_PROPERTY_ID.CREATION_TIMESTAMP;
pub const VSS_SPROPID_STATUS = VSS_SNAPSHOT_PROPERTY_ID.STATUS;

pub const VSS_FILE_SPEC_BACKUP_TYPE = enum(i32) {
    FULL_BACKUP_REQUIRED = 1,
    DIFFERENTIAL_BACKUP_REQUIRED = 2,
    INCREMENTAL_BACKUP_REQUIRED = 4,
    LOG_BACKUP_REQUIRED = 8,
    FULL_SNAPSHOT_REQUIRED = 256,
    DIFFERENTIAL_SNAPSHOT_REQUIRED = 512,
    INCREMENTAL_SNAPSHOT_REQUIRED = 1024,
    LOG_SNAPSHOT_REQUIRED = 2048,
    CREATED_DURING_BACKUP = 65536,
    ALL_BACKUP_REQUIRED = 15,
    ALL_SNAPSHOT_REQUIRED = 3840,
};
pub const VSS_FSBT_FULL_BACKUP_REQUIRED = VSS_FILE_SPEC_BACKUP_TYPE.FULL_BACKUP_REQUIRED;
pub const VSS_FSBT_DIFFERENTIAL_BACKUP_REQUIRED = VSS_FILE_SPEC_BACKUP_TYPE.DIFFERENTIAL_BACKUP_REQUIRED;
pub const VSS_FSBT_INCREMENTAL_BACKUP_REQUIRED = VSS_FILE_SPEC_BACKUP_TYPE.INCREMENTAL_BACKUP_REQUIRED;
pub const VSS_FSBT_LOG_BACKUP_REQUIRED = VSS_FILE_SPEC_BACKUP_TYPE.LOG_BACKUP_REQUIRED;
pub const VSS_FSBT_FULL_SNAPSHOT_REQUIRED = VSS_FILE_SPEC_BACKUP_TYPE.FULL_SNAPSHOT_REQUIRED;
pub const VSS_FSBT_DIFFERENTIAL_SNAPSHOT_REQUIRED = VSS_FILE_SPEC_BACKUP_TYPE.DIFFERENTIAL_SNAPSHOT_REQUIRED;
pub const VSS_FSBT_INCREMENTAL_SNAPSHOT_REQUIRED = VSS_FILE_SPEC_BACKUP_TYPE.INCREMENTAL_SNAPSHOT_REQUIRED;
pub const VSS_FSBT_LOG_SNAPSHOT_REQUIRED = VSS_FILE_SPEC_BACKUP_TYPE.LOG_SNAPSHOT_REQUIRED;
pub const VSS_FSBT_CREATED_DURING_BACKUP = VSS_FILE_SPEC_BACKUP_TYPE.CREATED_DURING_BACKUP;
pub const VSS_FSBT_ALL_BACKUP_REQUIRED = VSS_FILE_SPEC_BACKUP_TYPE.ALL_BACKUP_REQUIRED;
pub const VSS_FSBT_ALL_SNAPSHOT_REQUIRED = VSS_FILE_SPEC_BACKUP_TYPE.ALL_SNAPSHOT_REQUIRED;

pub const VSS_BACKUP_SCHEMA = enum(i32) {
    UNDEFINED = 0,
    DIFFERENTIAL = 1,
    INCREMENTAL = 2,
    EXCLUSIVE_INCREMENTAL_DIFFERENTIAL = 4,
    LOG = 8,
    COPY = 16,
    TIMESTAMPED = 32,
    LAST_MODIFY = 64,
    LSN = 128,
    WRITER_SUPPORTS_NEW_TARGET = 256,
    WRITER_SUPPORTS_RESTORE_WITH_MOVE = 512,
    INDEPENDENT_SYSTEM_STATE = 1024,
    ROLLFORWARD_RESTORE = 4096,
    RESTORE_RENAME = 8192,
    AUTHORITATIVE_RESTORE = 16384,
    WRITER_SUPPORTS_PARALLEL_RESTORES = 32768,
};
pub const VSS_BS_UNDEFINED = VSS_BACKUP_SCHEMA.UNDEFINED;
pub const VSS_BS_DIFFERENTIAL = VSS_BACKUP_SCHEMA.DIFFERENTIAL;
pub const VSS_BS_INCREMENTAL = VSS_BACKUP_SCHEMA.INCREMENTAL;
pub const VSS_BS_EXCLUSIVE_INCREMENTAL_DIFFERENTIAL = VSS_BACKUP_SCHEMA.EXCLUSIVE_INCREMENTAL_DIFFERENTIAL;
pub const VSS_BS_LOG = VSS_BACKUP_SCHEMA.LOG;
pub const VSS_BS_COPY = VSS_BACKUP_SCHEMA.COPY;
pub const VSS_BS_TIMESTAMPED = VSS_BACKUP_SCHEMA.TIMESTAMPED;
pub const VSS_BS_LAST_MODIFY = VSS_BACKUP_SCHEMA.LAST_MODIFY;
pub const VSS_BS_LSN = VSS_BACKUP_SCHEMA.LSN;
pub const VSS_BS_WRITER_SUPPORTS_NEW_TARGET = VSS_BACKUP_SCHEMA.WRITER_SUPPORTS_NEW_TARGET;
pub const VSS_BS_WRITER_SUPPORTS_RESTORE_WITH_MOVE = VSS_BACKUP_SCHEMA.WRITER_SUPPORTS_RESTORE_WITH_MOVE;
pub const VSS_BS_INDEPENDENT_SYSTEM_STATE = VSS_BACKUP_SCHEMA.INDEPENDENT_SYSTEM_STATE;
pub const VSS_BS_ROLLFORWARD_RESTORE = VSS_BACKUP_SCHEMA.ROLLFORWARD_RESTORE;
pub const VSS_BS_RESTORE_RENAME = VSS_BACKUP_SCHEMA.RESTORE_RENAME;
pub const VSS_BS_AUTHORITATIVE_RESTORE = VSS_BACKUP_SCHEMA.AUTHORITATIVE_RESTORE;
pub const VSS_BS_WRITER_SUPPORTS_PARALLEL_RESTORES = VSS_BACKUP_SCHEMA.WRITER_SUPPORTS_PARALLEL_RESTORES;

pub const VSS_SNAPSHOT_PROP = extern struct {
    m_SnapshotId: Guid,
    m_SnapshotSetId: Guid,
    m_lSnapshotsCount: i32,
    m_pwszSnapshotDeviceObject: ?*u16,
    m_pwszOriginalVolumeName: ?*u16,
    m_pwszOriginatingMachine: ?*u16,
    m_pwszServiceMachine: ?*u16,
    m_pwszExposedName: ?*u16,
    m_pwszExposedPath: ?*u16,
    m_ProviderId: Guid,
    m_lSnapshotAttributes: i32,
    m_tsCreationTimestamp: i64,
    m_eStatus: VSS_SNAPSHOT_STATE,
};

pub const VSS_PROVIDER_PROP = extern struct {
    m_ProviderId: Guid,
    m_pwszProviderName: ?*u16,
    m_eProviderType: VSS_PROVIDER_TYPE,
    m_pwszProviderVersion: ?*u16,
    m_ProviderVersionId: Guid,
    m_ClassId: Guid,
};

pub const VSS_OBJECT_UNION = extern union {
    Snap: VSS_SNAPSHOT_PROP,
    Prov: VSS_PROVIDER_PROP,
};

pub const VSS_OBJECT_PROP = extern struct {
    Type: VSS_OBJECT_TYPE,
    Obj: VSS_OBJECT_UNION,
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IVssEnumObject_Value = Guid.initString("ae1c7110-2f60-11d3-8a39-00c04f72d8e3");
pub const IID_IVssEnumObject = &IID_IVssEnumObject_Value;
pub const IVssEnumObject = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Next: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssEnumObject,
                celt: u32,
                rgelt: [*]VSS_OBJECT_PROP,
                pceltFetched: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssEnumObject,
                celt: u32,
                rgelt: [*]VSS_OBJECT_PROP,
                pceltFetched: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Skip: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssEnumObject,
                celt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssEnumObject,
                celt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssEnumObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssEnumObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Clone: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssEnumObject,
                ppenum: ?*?*IVssEnumObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssEnumObject,
                ppenum: ?*?*IVssEnumObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssEnumObject_Next(self: *const T, celt: u32, rgelt: [*]VSS_OBJECT_PROP, pceltFetched: ?*u32) HRESULT {
                return @as(*const IVssEnumObject.VTable, @ptrCast(self.vtable)).Next(@as(*const IVssEnumObject, @ptrCast(self)), celt, rgelt, pceltFetched);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssEnumObject_Skip(self: *const T, celt: u32) HRESULT {
                return @as(*const IVssEnumObject.VTable, @ptrCast(self.vtable)).Skip(@as(*const IVssEnumObject, @ptrCast(self)), celt);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssEnumObject_Reset(self: *const T) HRESULT {
                return @as(*const IVssEnumObject.VTable, @ptrCast(self.vtable)).Reset(@as(*const IVssEnumObject, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssEnumObject_Clone(self: *const T, ppenum: ?*?*IVssEnumObject) HRESULT {
                return @as(*const IVssEnumObject.VTable, @ptrCast(self.vtable)).Clone(@as(*const IVssEnumObject, @ptrCast(self)), ppenum);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows5.1.2600'
const IID_IVssAsync_Value = Guid.initString("507c37b4-cf5b-4e95-b0af-14eb9767467e");
pub const IID_IVssAsync = &IID_IVssAsync_Value;
pub const IVssAsync = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Wait: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssAsync,
                dwMilliseconds: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssAsync,
                dwMilliseconds: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QueryStatus: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssAsync,
                pHrResult: ?*HRESULT,
                pReserved: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssAsync,
                pHrResult: ?*HRESULT,
                pReserved: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssAsync_Cancel(self: *const T) HRESULT {
                return @as(*const IVssAsync.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IVssAsync, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssAsync_Wait(self: *const T, dwMilliseconds: u32) HRESULT {
                return @as(*const IVssAsync.VTable, @ptrCast(self.vtable)).Wait(@as(*const IVssAsync, @ptrCast(self)), dwMilliseconds);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssAsync_QueryStatus(self: *const T, pHrResult: ?*HRESULT, pReserved: ?*i32) HRESULT {
                return @as(*const IVssAsync.VTable, @ptrCast(self.vtable)).QueryStatus(@as(*const IVssAsync, @ptrCast(self)), pHrResult, pReserved);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const VSS_USAGE_TYPE = enum(i32) {
    UNDEFINED = 0,
    BOOTABLESYSTEMSTATE = 1,
    SYSTEMSERVICE = 2,
    USERDATA = 3,
    OTHER = 4,
};
pub const VSS_UT_UNDEFINED = VSS_USAGE_TYPE.UNDEFINED;
pub const VSS_UT_BOOTABLESYSTEMSTATE = VSS_USAGE_TYPE.BOOTABLESYSTEMSTATE;
pub const VSS_UT_SYSTEMSERVICE = VSS_USAGE_TYPE.SYSTEMSERVICE;
pub const VSS_UT_USERDATA = VSS_USAGE_TYPE.USERDATA;
pub const VSS_UT_OTHER = VSS_USAGE_TYPE.OTHER;

pub const VSS_SOURCE_TYPE = enum(i32) {
    UNDEFINED = 0,
    TRANSACTEDDB = 1,
    NONTRANSACTEDDB = 2,
    OTHER = 3,
};
pub const VSS_ST_UNDEFINED = VSS_SOURCE_TYPE.UNDEFINED;
pub const VSS_ST_TRANSACTEDDB = VSS_SOURCE_TYPE.TRANSACTEDDB;
pub const VSS_ST_NONTRANSACTEDDB = VSS_SOURCE_TYPE.NONTRANSACTEDDB;
pub const VSS_ST_OTHER = VSS_SOURCE_TYPE.OTHER;

pub const VSS_RESTOREMETHOD_ENUM = enum(i32) {
    UNDEFINED = 0,
    RESTORE_IF_NOT_THERE = 1,
    RESTORE_IF_CAN_REPLACE = 2,
    STOP_RESTORE_START = 3,
    RESTORE_TO_ALTERNATE_LOCATION = 4,
    RESTORE_AT_REBOOT = 5,
    RESTORE_AT_REBOOT_IF_CANNOT_REPLACE = 6,
    CUSTOM = 7,
    RESTORE_STOP_START = 8,
};
pub const VSS_RME_UNDEFINED = VSS_RESTOREMETHOD_ENUM.UNDEFINED;
pub const VSS_RME_RESTORE_IF_NOT_THERE = VSS_RESTOREMETHOD_ENUM.RESTORE_IF_NOT_THERE;
pub const VSS_RME_RESTORE_IF_CAN_REPLACE = VSS_RESTOREMETHOD_ENUM.RESTORE_IF_CAN_REPLACE;
pub const VSS_RME_STOP_RESTORE_START = VSS_RESTOREMETHOD_ENUM.STOP_RESTORE_START;
pub const VSS_RME_RESTORE_TO_ALTERNATE_LOCATION = VSS_RESTOREMETHOD_ENUM.RESTORE_TO_ALTERNATE_LOCATION;
pub const VSS_RME_RESTORE_AT_REBOOT = VSS_RESTOREMETHOD_ENUM.RESTORE_AT_REBOOT;
pub const VSS_RME_RESTORE_AT_REBOOT_IF_CANNOT_REPLACE = VSS_RESTOREMETHOD_ENUM.RESTORE_AT_REBOOT_IF_CANNOT_REPLACE;
pub const VSS_RME_CUSTOM = VSS_RESTOREMETHOD_ENUM.CUSTOM;
pub const VSS_RME_RESTORE_STOP_START = VSS_RESTOREMETHOD_ENUM.RESTORE_STOP_START;

pub const VSS_WRITERRESTORE_ENUM = enum(i32) {
    UNDEFINED = 0,
    NEVER = 1,
    IF_REPLACE_FAILS = 2,
    ALWAYS = 3,
};
pub const VSS_WRE_UNDEFINED = VSS_WRITERRESTORE_ENUM.UNDEFINED;
pub const VSS_WRE_NEVER = VSS_WRITERRESTORE_ENUM.NEVER;
pub const VSS_WRE_IF_REPLACE_FAILS = VSS_WRITERRESTORE_ENUM.IF_REPLACE_FAILS;
pub const VSS_WRE_ALWAYS = VSS_WRITERRESTORE_ENUM.ALWAYS;

pub const VSS_COMPONENT_TYPE = enum(i32) {
    UNDEFINED = 0,
    DATABASE = 1,
    FILEGROUP = 2,
};
pub const VSS_CT_UNDEFINED = VSS_COMPONENT_TYPE.UNDEFINED;
pub const VSS_CT_DATABASE = VSS_COMPONENT_TYPE.DATABASE;
pub const VSS_CT_FILEGROUP = VSS_COMPONENT_TYPE.FILEGROUP;

pub const VSS_ALTERNATE_WRITER_STATE = enum(i32) {
    UNDEFINED = 0,
    NO_ALTERNATE_WRITER = 1,
    ALTERNATE_WRITER_EXISTS = 2,
    THIS_IS_ALTERNATE_WRITER = 3,
};
pub const VSS_AWS_UNDEFINED = VSS_ALTERNATE_WRITER_STATE.UNDEFINED;
pub const VSS_AWS_NO_ALTERNATE_WRITER = VSS_ALTERNATE_WRITER_STATE.NO_ALTERNATE_WRITER;
pub const VSS_AWS_ALTERNATE_WRITER_EXISTS = VSS_ALTERNATE_WRITER_STATE.ALTERNATE_WRITER_EXISTS;
pub const VSS_AWS_THIS_IS_ALTERNATE_WRITER = VSS_ALTERNATE_WRITER_STATE.THIS_IS_ALTERNATE_WRITER;

pub const VSS_SUBSCRIBE_MASK = enum(i32) {
    POST_SNAPSHOT_FLAG = 1,
    BACKUP_EVENTS_FLAG = 2,
    RESTORE_EVENTS_FLAG = 4,
    IO_THROTTLING_FLAG = 8,
    ALL_FLAGS = -1,
};
pub const VSS_SM_POST_SNAPSHOT_FLAG = VSS_SUBSCRIBE_MASK.POST_SNAPSHOT_FLAG;
pub const VSS_SM_BACKUP_EVENTS_FLAG = VSS_SUBSCRIBE_MASK.BACKUP_EVENTS_FLAG;
pub const VSS_SM_RESTORE_EVENTS_FLAG = VSS_SUBSCRIBE_MASK.RESTORE_EVENTS_FLAG;
pub const VSS_SM_IO_THROTTLING_FLAG = VSS_SUBSCRIBE_MASK.IO_THROTTLING_FLAG;
pub const VSS_SM_ALL_FLAGS = VSS_SUBSCRIBE_MASK.ALL_FLAGS;

pub const VSS_RESTORE_TARGET = enum(i32) {
    UNDEFINED = 0,
    ORIGINAL = 1,
    ALTERNATE = 2,
    DIRECTED = 3,
    ORIGINAL_LOCATION = 4,
};
pub const VSS_RT_UNDEFINED = VSS_RESTORE_TARGET.UNDEFINED;
pub const VSS_RT_ORIGINAL = VSS_RESTORE_TARGET.ORIGINAL;
pub const VSS_RT_ALTERNATE = VSS_RESTORE_TARGET.ALTERNATE;
pub const VSS_RT_DIRECTED = VSS_RESTORE_TARGET.DIRECTED;
pub const VSS_RT_ORIGINAL_LOCATION = VSS_RESTORE_TARGET.ORIGINAL_LOCATION;

pub const VSS_FILE_RESTORE_STATUS = enum(i32) {
    UNDEFINED = 0,
    NONE = 1,
    ALL = 2,
    FAILED = 3,
};
pub const VSS_RS_UNDEFINED = VSS_FILE_RESTORE_STATUS.UNDEFINED;
pub const VSS_RS_NONE = VSS_FILE_RESTORE_STATUS.NONE;
pub const VSS_RS_ALL = VSS_FILE_RESTORE_STATUS.ALL;
pub const VSS_RS_FAILED = VSS_FILE_RESTORE_STATUS.FAILED;

pub const VSS_COMPONENT_FLAGS = enum(i32) {
    BACKUP_RECOVERY = 1,
    APP_ROLLBACK_RECOVERY = 2,
    NOT_SYSTEM_STATE = 4,
};
pub const VSS_CF_BACKUP_RECOVERY = VSS_COMPONENT_FLAGS.BACKUP_RECOVERY;
pub const VSS_CF_APP_ROLLBACK_RECOVERY = VSS_COMPONENT_FLAGS.APP_ROLLBACK_RECOVERY;
pub const VSS_CF_NOT_SYSTEM_STATE = VSS_COMPONENT_FLAGS.NOT_SYSTEM_STATE;

pub const IVssExamineWriterMetadata = extern struct {
    placeholder: usize, // TODO: why is this type empty?
};

pub const IVssWMFiledesc = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetPath: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWMFiledesc,
                pbstrPath: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWMFiledesc,
                pbstrPath: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFilespec: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWMFiledesc,
                pbstrFilespec: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWMFiledesc,
                pbstrFilespec: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRecursive: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWMFiledesc,
                pbRecursive: ?*bool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWMFiledesc,
                pbRecursive: ?*bool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAlternateLocation: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWMFiledesc,
                pbstrAlternateLocation: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWMFiledesc,
                pbstrAlternateLocation: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBackupTypeMask: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWMFiledesc,
                pdwTypeMask: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWMFiledesc,
                pdwTypeMask: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWMFiledesc_GetPath(self: *const T, pbstrPath: ?*?BSTR) HRESULT {
                return @as(*const IVssWMFiledesc.VTable, @ptrCast(self.vtable)).GetPath(@as(*const IVssWMFiledesc, @ptrCast(self)), pbstrPath);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWMFiledesc_GetFilespec(self: *const T, pbstrFilespec: ?*?BSTR) HRESULT {
                return @as(*const IVssWMFiledesc.VTable, @ptrCast(self.vtable)).GetFilespec(@as(*const IVssWMFiledesc, @ptrCast(self)), pbstrFilespec);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWMFiledesc_GetRecursive(self: *const T, pbRecursive: ?*bool) HRESULT {
                return @as(*const IVssWMFiledesc.VTable, @ptrCast(self.vtable)).GetRecursive(@as(*const IVssWMFiledesc, @ptrCast(self)), pbRecursive);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWMFiledesc_GetAlternateLocation(self: *const T, pbstrAlternateLocation: ?*?BSTR) HRESULT {
                return @as(*const IVssWMFiledesc.VTable, @ptrCast(self.vtable)).GetAlternateLocation(@as(*const IVssWMFiledesc, @ptrCast(self)), pbstrAlternateLocation);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWMFiledesc_GetBackupTypeMask(self: *const T, pdwTypeMask: ?*u32) HRESULT {
                return @as(*const IVssWMFiledesc.VTable, @ptrCast(self.vtable)).GetBackupTypeMask(@as(*const IVssWMFiledesc, @ptrCast(self)), pdwTypeMask);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const IVssWMDependency = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetWriterId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWMDependency,
                pWriterId: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWMDependency,
                pWriterId: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetLogicalPath: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWMDependency,
                pbstrLogicalPath: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWMDependency,
                pbstrLogicalPath: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetComponentName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWMDependency,
                pbstrComponentName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWMDependency,
                pbstrComponentName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWMDependency_GetWriterId(self: *const T, pWriterId: ?*Guid) HRESULT {
                return @as(*const IVssWMDependency.VTable, @ptrCast(self.vtable)).GetWriterId(@as(*const IVssWMDependency, @ptrCast(self)), pWriterId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWMDependency_GetLogicalPath(self: *const T, pbstrLogicalPath: ?*?BSTR) HRESULT {
                return @as(*const IVssWMDependency.VTable, @ptrCast(self.vtable)).GetLogicalPath(@as(*const IVssWMDependency, @ptrCast(self)), pbstrLogicalPath);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWMDependency_GetComponentName(self: *const T, pbstrComponentName: ?*?BSTR) HRESULT {
                return @as(*const IVssWMDependency.VTable, @ptrCast(self.vtable)).GetComponentName(@as(*const IVssWMDependency, @ptrCast(self)), pbstrComponentName);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IVssComponent_Value = Guid.initString("d2c72c96-c121-4518-b627-e5a93d010ead");
pub const IID_IVssComponent = &IID_IVssComponent_Value;
pub const IVssComponent = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetLogicalPath: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pbstrPath: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pbstrPath: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetComponentType: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pct: ?*VSS_COMPONENT_TYPE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pct: ?*VSS_COMPONENT_TYPE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetComponentName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pbstrName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pbstrName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBackupSucceeded: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pbSucceeded: ?*bool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pbSucceeded: ?*bool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAlternateLocationMappingCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pcMappings: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pcMappings: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAlternateLocationMapping: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                iMapping: u32,
                ppFiledesc: ?*?*IVssWMFiledesc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                iMapping: u32,
                ppFiledesc: ?*?*IVssWMFiledesc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetBackupMetadata: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                wszData: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                wszData: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBackupMetadata: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pbstrData: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pbstrData: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddPartialFile: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                wszPath: ?[*:0]const u16,
                wszFilename: ?[*:0]const u16,
                wszRanges: ?[*:0]const u16,
                wszMetadata: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                wszPath: ?[*:0]const u16,
                wszFilename: ?[*:0]const u16,
                wszRanges: ?[*:0]const u16,
                wszMetadata: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPartialFileCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pcPartialFiles: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pcPartialFiles: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPartialFile: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                iPartialFile: u32,
                pbstrPath: ?*?BSTR,
                pbstrFilename: ?*?BSTR,
                pbstrRange: ?*?BSTR,
                pbstrMetadata: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                iPartialFile: u32,
                pbstrPath: ?*?BSTR,
                pbstrFilename: ?*?BSTR,
                pbstrRange: ?*?BSTR,
                pbstrMetadata: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsSelectedForRestore: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pbSelectedForRestore: ?*bool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pbSelectedForRestore: ?*bool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAdditionalRestores: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pbAdditionalRestores: ?*bool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pbAdditionalRestores: ?*bool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetNewTargetCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pcNewTarget: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pcNewTarget: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetNewTarget: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                iNewTarget: u32,
                ppFiledesc: ?*?*IVssWMFiledesc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                iNewTarget: u32,
                ppFiledesc: ?*?*IVssWMFiledesc,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddDirectedTarget: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                wszSourcePath: ?[*:0]const u16,
                wszSourceFilename: ?[*:0]const u16,
                wszSourceRangeList: ?[*:0]const u16,
                wszDestinationPath: ?[*:0]const u16,
                wszDestinationFilename: ?[*:0]const u16,
                wszDestinationRangeList: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                wszSourcePath: ?[*:0]const u16,
                wszSourceFilename: ?[*:0]const u16,
                wszSourceRangeList: ?[*:0]const u16,
                wszDestinationPath: ?[*:0]const u16,
                wszDestinationFilename: ?[*:0]const u16,
                wszDestinationRangeList: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDirectedTargetCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pcDirectedTarget: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pcDirectedTarget: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDirectedTarget: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                iDirectedTarget: u32,
                pbstrSourcePath: ?*?BSTR,
                pbstrSourceFileName: ?*?BSTR,
                pbstrSourceRangeList: ?*?BSTR,
                pbstrDestinationPath: ?*?BSTR,
                pbstrDestinationFilename: ?*?BSTR,
                pbstrDestinationRangeList: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                iDirectedTarget: u32,
                pbstrSourcePath: ?*?BSTR,
                pbstrSourceFileName: ?*?BSTR,
                pbstrSourceRangeList: ?*?BSTR,
                pbstrDestinationPath: ?*?BSTR,
                pbstrDestinationFilename: ?*?BSTR,
                pbstrDestinationRangeList: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetRestoreMetadata: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                wszRestoreMetadata: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                wszRestoreMetadata: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRestoreMetadata: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pbstrRestoreMetadata: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pbstrRestoreMetadata: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetRestoreTarget: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                target: VSS_RESTORE_TARGET,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                target: VSS_RESTORE_TARGET,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRestoreTarget: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pTarget: ?*VSS_RESTORE_TARGET,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pTarget: ?*VSS_RESTORE_TARGET,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetPreRestoreFailureMsg: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                wszPreRestoreFailureMsg: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                wszPreRestoreFailureMsg: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPreRestoreFailureMsg: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pbstrPreRestoreFailureMsg: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pbstrPreRestoreFailureMsg: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetPostRestoreFailureMsg: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                wszPostRestoreFailureMsg: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                wszPostRestoreFailureMsg: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPostRestoreFailureMsg: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pbstrPostRestoreFailureMsg: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pbstrPostRestoreFailureMsg: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetBackupStamp: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                wszBackupStamp: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                wszBackupStamp: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBackupStamp: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pbstrBackupStamp: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pbstrBackupStamp: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPreviousBackupStamp: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pbstrBackupStamp: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pbstrBackupStamp: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBackupOptions: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pbstrBackupOptions: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pbstrBackupOptions: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRestoreOptions: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pbstrRestoreOptions: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pbstrRestoreOptions: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRestoreSubcomponentCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pcRestoreSubcomponent: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pcRestoreSubcomponent: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRestoreSubcomponent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                iComponent: u32,
                pbstrLogicalPath: ?*?BSTR,
                pbstrComponentName: ?*?BSTR,
                pbRepair: ?*bool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                iComponent: u32,
                pbstrLogicalPath: ?*?BSTR,
                pbstrComponentName: ?*?BSTR,
                pbRepair: ?*bool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFileRestoreStatus: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pStatus: ?*VSS_FILE_RESTORE_STATUS,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pStatus: ?*VSS_FILE_RESTORE_STATUS,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddDifferencedFilesByLastModifyTime: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: BOOL,
                ftLastModifyTime: FILETIME,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: BOOL,
                ftLastModifyTime: FILETIME,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddDifferencedFilesByLastModifyLSN: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: BOOL,
                bstrLsnString: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: BOOL,
                bstrLsnString: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDifferencedFilesCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                pcDifferencedFiles: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                pcDifferencedFiles: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDifferencedFile: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponent,
                iDifferencedFile: u32,
                pbstrPath: ?*?BSTR,
                pbstrFilespec: ?*?BSTR,
                pbRecursive: ?*BOOL,
                pbstrLsnString: ?*?BSTR,
                pftLastModifyTime: ?*FILETIME,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponent,
                iDifferencedFile: u32,
                pbstrPath: ?*?BSTR,
                pbstrFilespec: ?*?BSTR,
                pbRecursive: ?*BOOL,
                pbstrLsnString: ?*?BSTR,
                pftLastModifyTime: ?*FILETIME,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetLogicalPath(self: *const T, pbstrPath: ?*?BSTR) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetLogicalPath(@as(*const IVssComponent, @ptrCast(self)), pbstrPath);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetComponentType(self: *const T, pct: ?*VSS_COMPONENT_TYPE) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetComponentType(@as(*const IVssComponent, @ptrCast(self)), pct);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetComponentName(self: *const T, pbstrName: ?*?BSTR) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetComponentName(@as(*const IVssComponent, @ptrCast(self)), pbstrName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetBackupSucceeded(self: *const T, pbSucceeded: ?*bool) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetBackupSucceeded(@as(*const IVssComponent, @ptrCast(self)), pbSucceeded);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetAlternateLocationMappingCount(self: *const T, pcMappings: ?*u32) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetAlternateLocationMappingCount(@as(*const IVssComponent, @ptrCast(self)), pcMappings);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetAlternateLocationMapping(self: *const T, iMapping: u32, ppFiledesc: ?*?*IVssWMFiledesc) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetAlternateLocationMapping(@as(*const IVssComponent, @ptrCast(self)), iMapping, ppFiledesc);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_SetBackupMetadata(self: *const T, wszData: ?[*:0]const u16) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).SetBackupMetadata(@as(*const IVssComponent, @ptrCast(self)), wszData);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetBackupMetadata(self: *const T, pbstrData: ?*?BSTR) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetBackupMetadata(@as(*const IVssComponent, @ptrCast(self)), pbstrData);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_AddPartialFile(self: *const T, wszPath: ?[*:0]const u16, wszFilename: ?[*:0]const u16, wszRanges: ?[*:0]const u16, wszMetadata: ?[*:0]const u16) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).AddPartialFile(@as(*const IVssComponent, @ptrCast(self)), wszPath, wszFilename, wszRanges, wszMetadata);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetPartialFileCount(self: *const T, pcPartialFiles: ?*u32) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetPartialFileCount(@as(*const IVssComponent, @ptrCast(self)), pcPartialFiles);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetPartialFile(self: *const T, iPartialFile: u32, pbstrPath: ?*?BSTR, pbstrFilename: ?*?BSTR, pbstrRange: ?*?BSTR, pbstrMetadata: ?*?BSTR) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetPartialFile(@as(*const IVssComponent, @ptrCast(self)), iPartialFile, pbstrPath, pbstrFilename, pbstrRange, pbstrMetadata);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_IsSelectedForRestore(self: *const T, pbSelectedForRestore: ?*bool) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).IsSelectedForRestore(@as(*const IVssComponent, @ptrCast(self)), pbSelectedForRestore);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetAdditionalRestores(self: *const T, pbAdditionalRestores: ?*bool) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetAdditionalRestores(@as(*const IVssComponent, @ptrCast(self)), pbAdditionalRestores);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetNewTargetCount(self: *const T, pcNewTarget: ?*u32) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetNewTargetCount(@as(*const IVssComponent, @ptrCast(self)), pcNewTarget);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetNewTarget(self: *const T, iNewTarget: u32, ppFiledesc: ?*?*IVssWMFiledesc) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetNewTarget(@as(*const IVssComponent, @ptrCast(self)), iNewTarget, ppFiledesc);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_AddDirectedTarget(self: *const T, wszSourcePath: ?[*:0]const u16, wszSourceFilename: ?[*:0]const u16, wszSourceRangeList: ?[*:0]const u16, wszDestinationPath: ?[*:0]const u16, wszDestinationFilename: ?[*:0]const u16, wszDestinationRangeList: ?[*:0]const u16) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).AddDirectedTarget(@as(*const IVssComponent, @ptrCast(self)), wszSourcePath, wszSourceFilename, wszSourceRangeList, wszDestinationPath, wszDestinationFilename, wszDestinationRangeList);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetDirectedTargetCount(self: *const T, pcDirectedTarget: ?*u32) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetDirectedTargetCount(@as(*const IVssComponent, @ptrCast(self)), pcDirectedTarget);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetDirectedTarget(self: *const T, iDirectedTarget: u32, pbstrSourcePath: ?*?BSTR, pbstrSourceFileName: ?*?BSTR, pbstrSourceRangeList: ?*?BSTR, pbstrDestinationPath: ?*?BSTR, pbstrDestinationFilename: ?*?BSTR, pbstrDestinationRangeList: ?*?BSTR) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetDirectedTarget(@as(*const IVssComponent, @ptrCast(self)), iDirectedTarget, pbstrSourcePath, pbstrSourceFileName, pbstrSourceRangeList, pbstrDestinationPath, pbstrDestinationFilename, pbstrDestinationRangeList);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_SetRestoreMetadata(self: *const T, wszRestoreMetadata: ?[*:0]const u16) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).SetRestoreMetadata(@as(*const IVssComponent, @ptrCast(self)), wszRestoreMetadata);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetRestoreMetadata(self: *const T, pbstrRestoreMetadata: ?*?BSTR) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetRestoreMetadata(@as(*const IVssComponent, @ptrCast(self)), pbstrRestoreMetadata);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_SetRestoreTarget(self: *const T, target: VSS_RESTORE_TARGET) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).SetRestoreTarget(@as(*const IVssComponent, @ptrCast(self)), target);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetRestoreTarget(self: *const T, pTarget: ?*VSS_RESTORE_TARGET) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetRestoreTarget(@as(*const IVssComponent, @ptrCast(self)), pTarget);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_SetPreRestoreFailureMsg(self: *const T, wszPreRestoreFailureMsg: ?[*:0]const u16) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).SetPreRestoreFailureMsg(@as(*const IVssComponent, @ptrCast(self)), wszPreRestoreFailureMsg);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetPreRestoreFailureMsg(self: *const T, pbstrPreRestoreFailureMsg: ?*?BSTR) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetPreRestoreFailureMsg(@as(*const IVssComponent, @ptrCast(self)), pbstrPreRestoreFailureMsg);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_SetPostRestoreFailureMsg(self: *const T, wszPostRestoreFailureMsg: ?[*:0]const u16) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).SetPostRestoreFailureMsg(@as(*const IVssComponent, @ptrCast(self)), wszPostRestoreFailureMsg);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetPostRestoreFailureMsg(self: *const T, pbstrPostRestoreFailureMsg: ?*?BSTR) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetPostRestoreFailureMsg(@as(*const IVssComponent, @ptrCast(self)), pbstrPostRestoreFailureMsg);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_SetBackupStamp(self: *const T, wszBackupStamp: ?[*:0]const u16) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).SetBackupStamp(@as(*const IVssComponent, @ptrCast(self)), wszBackupStamp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetBackupStamp(self: *const T, pbstrBackupStamp: ?*?BSTR) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetBackupStamp(@as(*const IVssComponent, @ptrCast(self)), pbstrBackupStamp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetPreviousBackupStamp(self: *const T, pbstrBackupStamp: ?*?BSTR) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetPreviousBackupStamp(@as(*const IVssComponent, @ptrCast(self)), pbstrBackupStamp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetBackupOptions(self: *const T, pbstrBackupOptions: ?*?BSTR) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetBackupOptions(@as(*const IVssComponent, @ptrCast(self)), pbstrBackupOptions);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetRestoreOptions(self: *const T, pbstrRestoreOptions: ?*?BSTR) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetRestoreOptions(@as(*const IVssComponent, @ptrCast(self)), pbstrRestoreOptions);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetRestoreSubcomponentCount(self: *const T, pcRestoreSubcomponent: ?*u32) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetRestoreSubcomponentCount(@as(*const IVssComponent, @ptrCast(self)), pcRestoreSubcomponent);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetRestoreSubcomponent(self: *const T, iComponent: u32, pbstrLogicalPath: ?*?BSTR, pbstrComponentName: ?*?BSTR, pbRepair: ?*bool) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetRestoreSubcomponent(@as(*const IVssComponent, @ptrCast(self)), iComponent, pbstrLogicalPath, pbstrComponentName, pbRepair);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetFileRestoreStatus(self: *const T, pStatus: ?*VSS_FILE_RESTORE_STATUS) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetFileRestoreStatus(@as(*const IVssComponent, @ptrCast(self)), pStatus);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_AddDifferencedFilesByLastModifyTime(self: *const T, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, bRecursive: BOOL, ftLastModifyTime: FILETIME) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).AddDifferencedFilesByLastModifyTime(@as(*const IVssComponent, @ptrCast(self)), wszPath, wszFilespec, bRecursive, ftLastModifyTime);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_AddDifferencedFilesByLastModifyLSN(self: *const T, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, bRecursive: BOOL, bstrLsnString: ?BSTR) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).AddDifferencedFilesByLastModifyLSN(@as(*const IVssComponent, @ptrCast(self)), wszPath, wszFilespec, bRecursive, bstrLsnString);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetDifferencedFilesCount(self: *const T, pcDifferencedFiles: ?*u32) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetDifferencedFilesCount(@as(*const IVssComponent, @ptrCast(self)), pcDifferencedFiles);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponent_GetDifferencedFile(self: *const T, iDifferencedFile: u32, pbstrPath: ?*?BSTR, pbstrFilespec: ?*?BSTR, pbRecursive: ?*BOOL, pbstrLsnString: ?*?BSTR, pftLastModifyTime: ?*FILETIME) HRESULT {
                return @as(*const IVssComponent.VTable, @ptrCast(self.vtable)).GetDifferencedFile(@as(*const IVssComponent, @ptrCast(self)), iDifferencedFile, pbstrPath, pbstrFilespec, pbRecursive, pbstrLsnString, pftLastModifyTime);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const IVssWriterComponents = extern struct {
    pub const VTable = extern struct {
        GetComponentCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterComponents,
                pcComponents: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWriterComponents,
                pcComponents: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetWriterInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterComponents,
                pidInstance: ?*Guid,
                pidWriter: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWriterComponents,
                pidInstance: ?*Guid,
                pidWriter: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetComponent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterComponents,
                iComponent: u32,
                ppComponent: ?*?*IVssComponent,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWriterComponents,
                iComponent: u32,
                ppComponent: ?*?*IVssComponent,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterComponents_GetComponentCount(self: *const T, pcComponents: ?*u32) HRESULT {
                return @as(*const IVssWriterComponents.VTable, @ptrCast(self.vtable)).GetComponentCount(@as(*const IVssWriterComponents, @ptrCast(self)), pcComponents);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterComponents_GetWriterInfo(self: *const T, pidInstance: ?*Guid, pidWriter: ?*Guid) HRESULT {
                return @as(*const IVssWriterComponents.VTable, @ptrCast(self.vtable)).GetWriterInfo(@as(*const IVssWriterComponents, @ptrCast(self)), pidInstance, pidWriter);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterComponents_GetComponent(self: *const T, iComponent: u32, ppComponent: ?*?*IVssComponent) HRESULT {
                return @as(*const IVssWriterComponents.VTable, @ptrCast(self.vtable)).GetComponent(@as(*const IVssWriterComponents, @ptrCast(self)), iComponent, ppComponent);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IVssComponentEx_Value = Guid.initString("156c8b5e-f131-4bd7-9c97-d1923be7e1fa");
pub const IID_IVssComponentEx = &IID_IVssComponentEx_Value;
pub const IVssComponentEx = extern struct {
    pub const VTable = extern struct {
        base: IVssComponent.VTable,
        SetPrepareForBackupFailureMsg: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponentEx,
                wszFailureMsg: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponentEx,
                wszFailureMsg: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetPostSnapshotFailureMsg: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponentEx,
                wszFailureMsg: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponentEx,
                wszFailureMsg: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPrepareForBackupFailureMsg: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponentEx,
                pbstrFailureMsg: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponentEx,
                pbstrFailureMsg: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPostSnapshotFailureMsg: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponentEx,
                pbstrFailureMsg: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponentEx,
                pbstrFailureMsg: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAuthoritativeRestore: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponentEx,
                pbAuth: ?*bool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponentEx,
                pbAuth: ?*bool,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRollForward: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponentEx,
                pRollType: ?*VSS_ROLLFORWARD_TYPE,
                pbstrPoint: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponentEx,
                pRollType: ?*VSS_ROLLFORWARD_TYPE,
                pbstrPoint: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRestoreName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponentEx,
                pbstrName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponentEx,
                pbstrName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IVssComponent.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponentEx_SetPrepareForBackupFailureMsg(self: *const T, wszFailureMsg: ?[*:0]const u16) HRESULT {
                return @as(*const IVssComponentEx.VTable, @ptrCast(self.vtable)).SetPrepareForBackupFailureMsg(@as(*const IVssComponentEx, @ptrCast(self)), wszFailureMsg);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponentEx_SetPostSnapshotFailureMsg(self: *const T, wszFailureMsg: ?[*:0]const u16) HRESULT {
                return @as(*const IVssComponentEx.VTable, @ptrCast(self.vtable)).SetPostSnapshotFailureMsg(@as(*const IVssComponentEx, @ptrCast(self)), wszFailureMsg);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponentEx_GetPrepareForBackupFailureMsg(self: *const T, pbstrFailureMsg: ?*?BSTR) HRESULT {
                return @as(*const IVssComponentEx.VTable, @ptrCast(self.vtable)).GetPrepareForBackupFailureMsg(@as(*const IVssComponentEx, @ptrCast(self)), pbstrFailureMsg);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponentEx_GetPostSnapshotFailureMsg(self: *const T, pbstrFailureMsg: ?*?BSTR) HRESULT {
                return @as(*const IVssComponentEx.VTable, @ptrCast(self.vtable)).GetPostSnapshotFailureMsg(@as(*const IVssComponentEx, @ptrCast(self)), pbstrFailureMsg);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponentEx_GetAuthoritativeRestore(self: *const T, pbAuth: ?*bool) HRESULT {
                return @as(*const IVssComponentEx.VTable, @ptrCast(self.vtable)).GetAuthoritativeRestore(@as(*const IVssComponentEx, @ptrCast(self)), pbAuth);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponentEx_GetRollForward(self: *const T, pRollType: ?*VSS_ROLLFORWARD_TYPE, pbstrPoint: ?*?BSTR) HRESULT {
                return @as(*const IVssComponentEx.VTable, @ptrCast(self.vtable)).GetRollForward(@as(*const IVssComponentEx, @ptrCast(self)), pRollType, pbstrPoint);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponentEx_GetRestoreName(self: *const T, pbstrName: ?*?BSTR) HRESULT {
                return @as(*const IVssComponentEx.VTable, @ptrCast(self.vtable)).GetRestoreName(@as(*const IVssComponentEx, @ptrCast(self)), pbstrName);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IVssComponentEx2_Value = Guid.initString("3b5be0f2-07a9-4e4b-bdd3-cfdc8e2c0d2d");
pub const IID_IVssComponentEx2 = &IID_IVssComponentEx2_Value;
pub const IVssComponentEx2 = extern struct {
    pub const VTable = extern struct {
        base: IVssComponentEx.VTable,
        SetFailure: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponentEx2,
                hr: HRESULT,
                hrApplication: HRESULT,
                wszApplicationMessage: ?[*:0]const u16,
                dwReserved: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponentEx2,
                hr: HRESULT,
                hrApplication: HRESULT,
                wszApplicationMessage: ?[*:0]const u16,
                dwReserved: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFailure: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssComponentEx2,
                phr: ?*HRESULT,
                phrApplication: ?*HRESULT,
                pbstrApplicationMessage: ?*?BSTR,
                pdwReserved: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssComponentEx2,
                phr: ?*HRESULT,
                phrApplication: ?*HRESULT,
                pbstrApplicationMessage: ?*?BSTR,
                pdwReserved: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IVssComponentEx.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponentEx2_SetFailure(self: *const T, hr: HRESULT, hrApplication: HRESULT, wszApplicationMessage: ?[*:0]const u16, dwReserved: u32) HRESULT {
                return @as(*const IVssComponentEx2.VTable, @ptrCast(self.vtable)).SetFailure(@as(*const IVssComponentEx2, @ptrCast(self)), hr, hrApplication, wszApplicationMessage, dwReserved);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssComponentEx2_GetFailure(self: *const T, phr: ?*HRESULT, phrApplication: ?*HRESULT, pbstrApplicationMessage: ?*?BSTR, pdwReserved: ?*u32) HRESULT {
                return @as(*const IVssComponentEx2.VTable, @ptrCast(self.vtable)).GetFailure(@as(*const IVssComponentEx2, @ptrCast(self)), phr, phrApplication, pbstrApplicationMessage, pdwReserved);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const IVssCreateWriterMetadata = extern struct {
    pub const VTable = extern struct {
        AddIncludeFiles: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateWriterMetadata,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: u8,
                wszAlternateLocation: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateWriterMetadata,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: u8,
                wszAlternateLocation: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddExcludeFiles: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateWriterMetadata,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateWriterMetadata,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddComponent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateWriterMetadata,
                ct: VSS_COMPONENT_TYPE,
                wszLogicalPath: ?[*:0]const u16,
                wszComponentName: ?[*:0]const u16,
                wszCaption: ?[*:0]const u16,
                pbIcon: ?*const u8,
                cbIcon: u32,
                bRestoreMetadata: u8,
                bNotifyOnBackupComplete: u8,
                bSelectable: u8,
                bSelectableForRestore: u8,
                dwComponentFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateWriterMetadata,
                ct: VSS_COMPONENT_TYPE,
                wszLogicalPath: ?[*:0]const u16,
                wszComponentName: ?[*:0]const u16,
                wszCaption: ?[*:0]const u16,
                pbIcon: ?*const u8,
                cbIcon: u32,
                bRestoreMetadata: u8,
                bNotifyOnBackupComplete: u8,
                bSelectable: u8,
                bSelectableForRestore: u8,
                dwComponentFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddDatabaseFiles: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateWriterMetadata,
                wszLogicalPath: ?[*:0]const u16,
                wszDatabaseName: ?[*:0]const u16,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                dwBackupTypeMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateWriterMetadata,
                wszLogicalPath: ?[*:0]const u16,
                wszDatabaseName: ?[*:0]const u16,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                dwBackupTypeMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddDatabaseLogFiles: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateWriterMetadata,
                wszLogicalPath: ?[*:0]const u16,
                wszDatabaseName: ?[*:0]const u16,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                dwBackupTypeMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateWriterMetadata,
                wszLogicalPath: ?[*:0]const u16,
                wszDatabaseName: ?[*:0]const u16,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                dwBackupTypeMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddFilesToFileGroup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateWriterMetadata,
                wszLogicalPath: ?[*:0]const u16,
                wszGroupName: ?[*:0]const u16,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: u8,
                wszAlternateLocation: ?[*:0]const u16,
                dwBackupTypeMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateWriterMetadata,
                wszLogicalPath: ?[*:0]const u16,
                wszGroupName: ?[*:0]const u16,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: u8,
                wszAlternateLocation: ?[*:0]const u16,
                dwBackupTypeMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetRestoreMethod: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateWriterMetadata,
                method: VSS_RESTOREMETHOD_ENUM,
                wszService: ?[*:0]const u16,
                wszUserProcedure: ?[*:0]const u16,
                writerRestore: VSS_WRITERRESTORE_ENUM,
                bRebootRequired: u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateWriterMetadata,
                method: VSS_RESTOREMETHOD_ENUM,
                wszService: ?[*:0]const u16,
                wszUserProcedure: ?[*:0]const u16,
                writerRestore: VSS_WRITERRESTORE_ENUM,
                bRebootRequired: u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddAlternateLocationMapping: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateWriterMetadata,
                wszSourcePath: ?[*:0]const u16,
                wszSourceFilespec: ?[*:0]const u16,
                bRecursive: u8,
                wszDestination: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateWriterMetadata,
                wszSourcePath: ?[*:0]const u16,
                wszSourceFilespec: ?[*:0]const u16,
                bRecursive: u8,
                wszDestination: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddComponentDependency: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateWriterMetadata,
                wszForLogicalPath: ?[*:0]const u16,
                wszForComponentName: ?[*:0]const u16,
                onWriterId: Guid,
                wszOnLogicalPath: ?[*:0]const u16,
                wszOnComponentName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateWriterMetadata,
                wszForLogicalPath: ?[*:0]const u16,
                wszForComponentName: ?[*:0]const u16,
                onWriterId: Guid,
                wszOnLogicalPath: ?[*:0]const u16,
                wszOnComponentName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetBackupSchema: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateWriterMetadata,
                dwSchemaMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateWriterMetadata,
                dwSchemaMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDocument: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateWriterMetadata,
                pDoc: ?*?*IXMLDOMDocument,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateWriterMetadata,
                pDoc: ?*?*IXMLDOMDocument,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SaveAsXML: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateWriterMetadata,
                pbstrXML: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateWriterMetadata,
                pbstrXML: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateWriterMetadata_AddIncludeFiles(self: *const T, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, bRecursive: u8, wszAlternateLocation: ?[*:0]const u16) HRESULT {
                return @as(*const IVssCreateWriterMetadata.VTable, @ptrCast(self.vtable)).AddIncludeFiles(@as(*const IVssCreateWriterMetadata, @ptrCast(self)), wszPath, wszFilespec, bRecursive, wszAlternateLocation);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateWriterMetadata_AddExcludeFiles(self: *const T, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, bRecursive: u8) HRESULT {
                return @as(*const IVssCreateWriterMetadata.VTable, @ptrCast(self.vtable)).AddExcludeFiles(@as(*const IVssCreateWriterMetadata, @ptrCast(self)), wszPath, wszFilespec, bRecursive);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateWriterMetadata_AddComponent(self: *const T, ct: VSS_COMPONENT_TYPE, wszLogicalPath: ?[*:0]const u16, wszComponentName: ?[*:0]const u16, wszCaption: ?[*:0]const u16, pbIcon: ?*const u8, cbIcon: u32, bRestoreMetadata: u8, bNotifyOnBackupComplete: u8, bSelectable: u8, bSelectableForRestore: u8, dwComponentFlags: u32) HRESULT {
                return @as(*const IVssCreateWriterMetadata.VTable, @ptrCast(self.vtable)).AddComponent(@as(*const IVssCreateWriterMetadata, @ptrCast(self)), ct, wszLogicalPath, wszComponentName, wszCaption, pbIcon, cbIcon, bRestoreMetadata, bNotifyOnBackupComplete, bSelectable, bSelectableForRestore, dwComponentFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateWriterMetadata_AddDatabaseFiles(self: *const T, wszLogicalPath: ?[*:0]const u16, wszDatabaseName: ?[*:0]const u16, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, dwBackupTypeMask: u32) HRESULT {
                return @as(*const IVssCreateWriterMetadata.VTable, @ptrCast(self.vtable)).AddDatabaseFiles(@as(*const IVssCreateWriterMetadata, @ptrCast(self)), wszLogicalPath, wszDatabaseName, wszPath, wszFilespec, dwBackupTypeMask);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateWriterMetadata_AddDatabaseLogFiles(self: *const T, wszLogicalPath: ?[*:0]const u16, wszDatabaseName: ?[*:0]const u16, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, dwBackupTypeMask: u32) HRESULT {
                return @as(*const IVssCreateWriterMetadata.VTable, @ptrCast(self.vtable)).AddDatabaseLogFiles(@as(*const IVssCreateWriterMetadata, @ptrCast(self)), wszLogicalPath, wszDatabaseName, wszPath, wszFilespec, dwBackupTypeMask);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateWriterMetadata_AddFilesToFileGroup(self: *const T, wszLogicalPath: ?[*:0]const u16, wszGroupName: ?[*:0]const u16, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, bRecursive: u8, wszAlternateLocation: ?[*:0]const u16, dwBackupTypeMask: u32) HRESULT {
                return @as(*const IVssCreateWriterMetadata.VTable, @ptrCast(self.vtable)).AddFilesToFileGroup(@as(*const IVssCreateWriterMetadata, @ptrCast(self)), wszLogicalPath, wszGroupName, wszPath, wszFilespec, bRecursive, wszAlternateLocation, dwBackupTypeMask);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateWriterMetadata_SetRestoreMethod(self: *const T, method: VSS_RESTOREMETHOD_ENUM, wszService: ?[*:0]const u16, wszUserProcedure: ?[*:0]const u16, writerRestore: VSS_WRITERRESTORE_ENUM, bRebootRequired: u8) HRESULT {
                return @as(*const IVssCreateWriterMetadata.VTable, @ptrCast(self.vtable)).SetRestoreMethod(@as(*const IVssCreateWriterMetadata, @ptrCast(self)), method, wszService, wszUserProcedure, writerRestore, bRebootRequired);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateWriterMetadata_AddAlternateLocationMapping(self: *const T, wszSourcePath: ?[*:0]const u16, wszSourceFilespec: ?[*:0]const u16, bRecursive: u8, wszDestination: ?[*:0]const u16) HRESULT {
                return @as(*const IVssCreateWriterMetadata.VTable, @ptrCast(self.vtable)).AddAlternateLocationMapping(@as(*const IVssCreateWriterMetadata, @ptrCast(self)), wszSourcePath, wszSourceFilespec, bRecursive, wszDestination);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateWriterMetadata_AddComponentDependency(self: *const T, wszForLogicalPath: ?[*:0]const u16, wszForComponentName: ?[*:0]const u16, onWriterId: Guid, wszOnLogicalPath: ?[*:0]const u16, wszOnComponentName: ?[*:0]const u16) HRESULT {
                return @as(*const IVssCreateWriterMetadata.VTable, @ptrCast(self.vtable)).AddComponentDependency(@as(*const IVssCreateWriterMetadata, @ptrCast(self)), wszForLogicalPath, wszForComponentName, onWriterId, wszOnLogicalPath, wszOnComponentName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateWriterMetadata_SetBackupSchema(self: *const T, dwSchemaMask: u32) HRESULT {
                return @as(*const IVssCreateWriterMetadata.VTable, @ptrCast(self.vtable)).SetBackupSchema(@as(*const IVssCreateWriterMetadata, @ptrCast(self)), dwSchemaMask);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateWriterMetadata_GetDocument(self: *const T, pDoc: ?*?*IXMLDOMDocument) HRESULT {
                return @as(*const IVssCreateWriterMetadata.VTable, @ptrCast(self.vtable)).GetDocument(@as(*const IVssCreateWriterMetadata, @ptrCast(self)), pDoc);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateWriterMetadata_SaveAsXML(self: *const T, pbstrXML: ?*?BSTR) HRESULT {
                return @as(*const IVssCreateWriterMetadata.VTable, @ptrCast(self.vtable)).SaveAsXML(@as(*const IVssCreateWriterMetadata, @ptrCast(self)), pbstrXML);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const IVssWriterImpl = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Initialize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
                writerId: Guid,
                wszWriterName: ?[*:0]const u16,
                wszWriterInstanceName: ?[*:0]const u16,
                dwMajorVersion: u32,
                dwMinorVersion: u32,
                ut: VSS_USAGE_TYPE,
                st: VSS_SOURCE_TYPE,
                nLevel: VSS_APPLICATION_LEVEL,
                dwTimeout: u32,
                aws: VSS_ALTERNATE_WRITER_STATE,
                bIOThrottlingOnly: u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWriterImpl,
                writerId: Guid,
                wszWriterName: ?[*:0]const u16,
                wszWriterInstanceName: ?[*:0]const u16,
                dwMajorVersion: u32,
                dwMinorVersion: u32,
                ut: VSS_USAGE_TYPE,
                st: VSS_SOURCE_TYPE,
                nLevel: VSS_APPLICATION_LEVEL,
                dwTimeout: u32,
                aws: VSS_ALTERNATE_WRITER_STATE,
                bIOThrottlingOnly: u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Subscribe: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
                dwSubscribeTimeout: u32,
                dwEventFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWriterImpl,
                dwSubscribeTimeout: u32,
                dwEventFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Unsubscribe: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Uninitialize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) void,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) void,
        },
        GetCurrentVolumeArray: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) ?*?PWSTR,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) ?*?PWSTR,
        },
        GetCurrentVolumeCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) u32,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) u32,
        },
        GetSnapshotDeviceName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
                wszOriginalVolume: ?[*:0]const u16,
                ppwszSnapshotDevice: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWriterImpl,
                wszOriginalVolume: ?[*:0]const u16,
                ppwszSnapshotDevice: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCurrentSnapshotSetId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) Guid,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) Guid,
        },
        GetContext: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) i32,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) i32,
        },
        GetCurrentLevel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) VSS_APPLICATION_LEVEL,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) VSS_APPLICATION_LEVEL,
        },
        IsPathAffected: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
                wszPath: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) bool,
            else => *const fn (
                self: *const IVssWriterImpl,
                wszPath: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) bool,
        },
        IsBootableSystemStateBackedUp: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) bool,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) bool,
        },
        AreComponentsSelected: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) bool,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) bool,
        },
        GetBackupType: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) VSS_BACKUP_TYPE,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) VSS_BACKUP_TYPE,
        },
        GetRestoreType: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) VSS_RESTORE_TYPE,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) VSS_RESTORE_TYPE,
        },
        SetWriterFailure: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWriterImpl,
                hr: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsPartialFileSupportEnabled: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) bool,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) bool,
        },
        InstallAlternateWriter: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
                idWriter: Guid,
                clsid: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWriterImpl,
                idWriter: Guid,
                clsid: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetIdentityInformation: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) ?*IVssExamineWriterMetadata,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) ?*IVssExamineWriterMetadata,
        },
        SetWriterFailureEx: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
                hr: HRESULT,
                hrApplication: HRESULT,
                wszApplicationMessage: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWriterImpl,
                hr: HRESULT,
                hrApplication: HRESULT,
                wszApplicationMessage: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSessionId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
                idSession: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssWriterImpl,
                idSession: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsWriterShuttingDown: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) bool,
            else => *const fn (
                self: *const IVssWriterImpl,
            ) callconv(@import("std").os.windows.WINAPI) bool,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_Initialize(self: *const T, writerId: Guid, wszWriterName: ?[*:0]const u16, wszWriterInstanceName: ?[*:0]const u16, dwMajorVersion: u32, dwMinorVersion: u32, ut: VSS_USAGE_TYPE, st: VSS_SOURCE_TYPE, nLevel: VSS_APPLICATION_LEVEL, dwTimeout: u32, aws: VSS_ALTERNATE_WRITER_STATE, bIOThrottlingOnly: u8) HRESULT {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IVssWriterImpl, @ptrCast(self)), writerId, wszWriterName, wszWriterInstanceName, dwMajorVersion, dwMinorVersion, ut, st, nLevel, dwTimeout, aws, bIOThrottlingOnly);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_Subscribe(self: *const T, dwSubscribeTimeout: u32, dwEventFlags: u32) HRESULT {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).Subscribe(@as(*const IVssWriterImpl, @ptrCast(self)), dwSubscribeTimeout, dwEventFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_Unsubscribe(self: *const T) HRESULT {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).Unsubscribe(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_Uninitialize(self: *const T) void {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).Uninitialize(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_GetCurrentVolumeArray(self: *const T) ?*?PWSTR {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).GetCurrentVolumeArray(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_GetCurrentVolumeCount(self: *const T) u32 {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).GetCurrentVolumeCount(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_GetSnapshotDeviceName(self: *const T, wszOriginalVolume: ?[*:0]const u16, ppwszSnapshotDevice: ?*?PWSTR) HRESULT {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).GetSnapshotDeviceName(@as(*const IVssWriterImpl, @ptrCast(self)), wszOriginalVolume, ppwszSnapshotDevice);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_GetCurrentSnapshotSetId(self: *const T) Guid {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).GetCurrentSnapshotSetId(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_GetContext(self: *const T) i32 {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).GetContext(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_GetCurrentLevel(self: *const T) VSS_APPLICATION_LEVEL {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).GetCurrentLevel(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_IsPathAffected(self: *const T, wszPath: ?[*:0]const u16) bool {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).IsPathAffected(@as(*const IVssWriterImpl, @ptrCast(self)), wszPath);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_IsBootableSystemStateBackedUp(self: *const T) bool {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).IsBootableSystemStateBackedUp(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_AreComponentsSelected(self: *const T) bool {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).AreComponentsSelected(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_GetBackupType(self: *const T) VSS_BACKUP_TYPE {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).GetBackupType(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_GetRestoreType(self: *const T) VSS_RESTORE_TYPE {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).GetRestoreType(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_SetWriterFailure(self: *const T, hr: HRESULT) HRESULT {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).SetWriterFailure(@as(*const IVssWriterImpl, @ptrCast(self)), hr);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_IsPartialFileSupportEnabled(self: *const T) bool {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).IsPartialFileSupportEnabled(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_InstallAlternateWriter(self: *const T, idWriter: Guid, clsid: Guid) HRESULT {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).InstallAlternateWriter(@as(*const IVssWriterImpl, @ptrCast(self)), idWriter, clsid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_GetIdentityInformation(self: *const T) ?*IVssExamineWriterMetadata {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).GetIdentityInformation(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_SetWriterFailureEx(self: *const T, hr: HRESULT, hrApplication: HRESULT, wszApplicationMessage: ?[*:0]const u16) HRESULT {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).SetWriterFailureEx(@as(*const IVssWriterImpl, @ptrCast(self)), hr, hrApplication, wszApplicationMessage);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_GetSessionId(self: *const T, idSession: ?*Guid) HRESULT {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).GetSessionId(@as(*const IVssWriterImpl, @ptrCast(self)), idSession);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssWriterImpl_IsWriterShuttingDown(self: *const T) bool {
                return @as(*const IVssWriterImpl.VTable, @ptrCast(self.vtable)).IsWriterShuttingDown(@as(*const IVssWriterImpl, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IVssCreateExpressWriterMetadata_Value = Guid.initString("9c772e77-b26e-427f-92dd-c996f41ea5e3");
pub const IID_IVssCreateExpressWriterMetadata = &IID_IVssCreateExpressWriterMetadata_Value;
pub const IVssCreateExpressWriterMetadata = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        AddExcludeFiles: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateExpressWriterMetadata,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateExpressWriterMetadata,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddComponent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateExpressWriterMetadata,
                ct: VSS_COMPONENT_TYPE,
                wszLogicalPath: ?[*:0]const u16,
                wszComponentName: ?[*:0]const u16,
                wszCaption: ?[*:0]const u16,
                pbIcon: ?*const u8,
                cbIcon: u32,
                bRestoreMetadata: u8,
                bNotifyOnBackupComplete: u8,
                bSelectable: u8,
                bSelectableForRestore: u8,
                dwComponentFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateExpressWriterMetadata,
                ct: VSS_COMPONENT_TYPE,
                wszLogicalPath: ?[*:0]const u16,
                wszComponentName: ?[*:0]const u16,
                wszCaption: ?[*:0]const u16,
                pbIcon: ?*const u8,
                cbIcon: u32,
                bRestoreMetadata: u8,
                bNotifyOnBackupComplete: u8,
                bSelectable: u8,
                bSelectableForRestore: u8,
                dwComponentFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddFilesToFileGroup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateExpressWriterMetadata,
                wszLogicalPath: ?[*:0]const u16,
                wszGroupName: ?[*:0]const u16,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: u8,
                wszAlternateLocation: ?[*:0]const u16,
                dwBackupTypeMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateExpressWriterMetadata,
                wszLogicalPath: ?[*:0]const u16,
                wszGroupName: ?[*:0]const u16,
                wszPath: ?[*:0]const u16,
                wszFilespec: ?[*:0]const u16,
                bRecursive: u8,
                wszAlternateLocation: ?[*:0]const u16,
                dwBackupTypeMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetRestoreMethod: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateExpressWriterMetadata,
                method: VSS_RESTOREMETHOD_ENUM,
                wszService: ?[*:0]const u16,
                wszUserProcedure: ?[*:0]const u16,
                writerRestore: VSS_WRITERRESTORE_ENUM,
                bRebootRequired: u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateExpressWriterMetadata,
                method: VSS_RESTOREMETHOD_ENUM,
                wszService: ?[*:0]const u16,
                wszUserProcedure: ?[*:0]const u16,
                writerRestore: VSS_WRITERRESTORE_ENUM,
                bRebootRequired: u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddComponentDependency: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateExpressWriterMetadata,
                wszForLogicalPath: ?[*:0]const u16,
                wszForComponentName: ?[*:0]const u16,
                onWriterId: Guid,
                wszOnLogicalPath: ?[*:0]const u16,
                wszOnComponentName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateExpressWriterMetadata,
                wszForLogicalPath: ?[*:0]const u16,
                wszForComponentName: ?[*:0]const u16,
                onWriterId: Guid,
                wszOnLogicalPath: ?[*:0]const u16,
                wszOnComponentName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetBackupSchema: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateExpressWriterMetadata,
                dwSchemaMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateExpressWriterMetadata,
                dwSchemaMask: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SaveAsXML: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssCreateExpressWriterMetadata,
                pbstrXML: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssCreateExpressWriterMetadata,
                pbstrXML: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateExpressWriterMetadata_AddExcludeFiles(self: *const T, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, bRecursive: u8) HRESULT {
                return @as(*const IVssCreateExpressWriterMetadata.VTable, @ptrCast(self.vtable)).AddExcludeFiles(@as(*const IVssCreateExpressWriterMetadata, @ptrCast(self)), wszPath, wszFilespec, bRecursive);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateExpressWriterMetadata_AddComponent(self: *const T, ct: VSS_COMPONENT_TYPE, wszLogicalPath: ?[*:0]const u16, wszComponentName: ?[*:0]const u16, wszCaption: ?[*:0]const u16, pbIcon: ?*const u8, cbIcon: u32, bRestoreMetadata: u8, bNotifyOnBackupComplete: u8, bSelectable: u8, bSelectableForRestore: u8, dwComponentFlags: u32) HRESULT {
                return @as(*const IVssCreateExpressWriterMetadata.VTable, @ptrCast(self.vtable)).AddComponent(@as(*const IVssCreateExpressWriterMetadata, @ptrCast(self)), ct, wszLogicalPath, wszComponentName, wszCaption, pbIcon, cbIcon, bRestoreMetadata, bNotifyOnBackupComplete, bSelectable, bSelectableForRestore, dwComponentFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateExpressWriterMetadata_AddFilesToFileGroup(self: *const T, wszLogicalPath: ?[*:0]const u16, wszGroupName: ?[*:0]const u16, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, bRecursive: u8, wszAlternateLocation: ?[*:0]const u16, dwBackupTypeMask: u32) HRESULT {
                return @as(*const IVssCreateExpressWriterMetadata.VTable, @ptrCast(self.vtable)).AddFilesToFileGroup(@as(*const IVssCreateExpressWriterMetadata, @ptrCast(self)), wszLogicalPath, wszGroupName, wszPath, wszFilespec, bRecursive, wszAlternateLocation, dwBackupTypeMask);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateExpressWriterMetadata_SetRestoreMethod(self: *const T, method: VSS_RESTOREMETHOD_ENUM, wszService: ?[*:0]const u16, wszUserProcedure: ?[*:0]const u16, writerRestore: VSS_WRITERRESTORE_ENUM, bRebootRequired: u8) HRESULT {
                return @as(*const IVssCreateExpressWriterMetadata.VTable, @ptrCast(self.vtable)).SetRestoreMethod(@as(*const IVssCreateExpressWriterMetadata, @ptrCast(self)), method, wszService, wszUserProcedure, writerRestore, bRebootRequired);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateExpressWriterMetadata_AddComponentDependency(self: *const T, wszForLogicalPath: ?[*:0]const u16, wszForComponentName: ?[*:0]const u16, onWriterId: Guid, wszOnLogicalPath: ?[*:0]const u16, wszOnComponentName: ?[*:0]const u16) HRESULT {
                return @as(*const IVssCreateExpressWriterMetadata.VTable, @ptrCast(self.vtable)).AddComponentDependency(@as(*const IVssCreateExpressWriterMetadata, @ptrCast(self)), wszForLogicalPath, wszForComponentName, onWriterId, wszOnLogicalPath, wszOnComponentName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateExpressWriterMetadata_SetBackupSchema(self: *const T, dwSchemaMask: u32) HRESULT {
                return @as(*const IVssCreateExpressWriterMetadata.VTable, @ptrCast(self.vtable)).SetBackupSchema(@as(*const IVssCreateExpressWriterMetadata, @ptrCast(self)), dwSchemaMask);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssCreateExpressWriterMetadata_SaveAsXML(self: *const T, pbstrXML: ?*?BSTR) HRESULT {
                return @as(*const IVssCreateExpressWriterMetadata.VTable, @ptrCast(self.vtable)).SaveAsXML(@as(*const IVssCreateExpressWriterMetadata, @ptrCast(self)), pbstrXML);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IVssExpressWriter_Value = Guid.initString("e33affdc-59c7-47b1-97d5-4266598f6235");
pub const IID_IVssExpressWriter = &IID_IVssExpressWriter_Value;
pub const IVssExpressWriter = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        CreateMetadata: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssExpressWriter,
                writerId: Guid,
                writerName: ?[*:0]const u16,
                usageType: VSS_USAGE_TYPE,
                versionMajor: u32,
                versionMinor: u32,
                reserved: u32,
                ppMetadata: ?*?*IVssCreateExpressWriterMetadata,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssExpressWriter,
                writerId: Guid,
                writerName: ?[*:0]const u16,
                usageType: VSS_USAGE_TYPE,
                versionMajor: u32,
                versionMinor: u32,
                reserved: u32,
                ppMetadata: ?*?*IVssCreateExpressWriterMetadata,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        LoadMetadata: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssExpressWriter,
                metadata: ?[*:0]const u16,
                reserved: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssExpressWriter,
                metadata: ?[*:0]const u16,
                reserved: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Register: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssExpressWriter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssExpressWriter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Unregister: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssExpressWriter,
                writerId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssExpressWriter,
                writerId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssExpressWriter_CreateMetadata(self: *const T, writerId: Guid, writerName: ?[*:0]const u16, usageType: VSS_USAGE_TYPE, versionMajor: u32, versionMinor: u32, reserved: u32, ppMetadata: ?*?*IVssCreateExpressWriterMetadata) HRESULT {
                return @as(*const IVssExpressWriter.VTable, @ptrCast(self.vtable)).CreateMetadata(@as(*const IVssExpressWriter, @ptrCast(self)), writerId, writerName, usageType, versionMajor, versionMinor, reserved, ppMetadata);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssExpressWriter_LoadMetadata(self: *const T, metadata: ?[*:0]const u16, reserved: u32) HRESULT {
                return @as(*const IVssExpressWriter.VTable, @ptrCast(self.vtable)).LoadMetadata(@as(*const IVssExpressWriter, @ptrCast(self)), metadata, reserved);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssExpressWriter_Register(self: *const T) HRESULT {
                return @as(*const IVssExpressWriter.VTable, @ptrCast(self.vtable)).Register(@as(*const IVssExpressWriter, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssExpressWriter_Unregister(self: *const T, writerId: Guid) HRESULT {
                return @as(*const IVssExpressWriter.VTable, @ptrCast(self.vtable)).Unregister(@as(*const IVssExpressWriter, @ptrCast(self)), writerId);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const CLSID_VssSnapshotMgmt_Value = Guid.initString("0b5a2c52-3eb9-470a-96e2-6c6d4570e40f");
pub const CLSID_VssSnapshotMgmt = &CLSID_VssSnapshotMgmt_Value;

pub const VSS_MGMT_OBJECT_TYPE = enum(i32) {
    UNKNOWN = 0,
    VOLUME = 1,
    DIFF_VOLUME = 2,
    DIFF_AREA = 3,
};
pub const VSS_MGMT_OBJECT_UNKNOWN = VSS_MGMT_OBJECT_TYPE.UNKNOWN;
pub const VSS_MGMT_OBJECT_VOLUME = VSS_MGMT_OBJECT_TYPE.VOLUME;
pub const VSS_MGMT_OBJECT_DIFF_VOLUME = VSS_MGMT_OBJECT_TYPE.DIFF_VOLUME;
pub const VSS_MGMT_OBJECT_DIFF_AREA = VSS_MGMT_OBJECT_TYPE.DIFF_AREA;

pub const VSS_VOLUME_PROP = extern struct {
    m_pwszVolumeName: ?*u16,
    m_pwszVolumeDisplayName: ?*u16,
};

pub const VSS_DIFF_VOLUME_PROP = extern struct {
    m_pwszVolumeName: ?*u16,
    m_pwszVolumeDisplayName: ?*u16,
    m_llVolumeFreeSpace: i64,
    m_llVolumeTotalSpace: i64,
};

pub const VSS_DIFF_AREA_PROP = extern struct {
    m_pwszVolumeName: ?*u16,
    m_pwszDiffAreaVolumeName: ?*u16,
    m_llMaximumDiffSpace: i64,
    m_llAllocatedDiffSpace: i64,
    m_llUsedDiffSpace: i64,
};

pub const VSS_MGMT_OBJECT_UNION = extern union {
    Vol: VSS_VOLUME_PROP,
    DiffVol: VSS_DIFF_VOLUME_PROP,
    DiffArea: VSS_DIFF_AREA_PROP,
};

pub const VSS_MGMT_OBJECT_PROP = extern struct {
    Type: VSS_MGMT_OBJECT_TYPE,
    Obj: VSS_MGMT_OBJECT_UNION,
};

pub const VSS_PROTECTION_LEVEL = enum(i32) {
    ORIGINAL_VOLUME = 0,
    SNAPSHOT = 1,
};
pub const VSS_PROTECTION_LEVEL_ORIGINAL_VOLUME = VSS_PROTECTION_LEVEL.ORIGINAL_VOLUME;
pub const VSS_PROTECTION_LEVEL_SNAPSHOT = VSS_PROTECTION_LEVEL.SNAPSHOT;

pub const VSS_PROTECTION_FAULT = enum(i32) {
    NONE = 0,
    DIFF_AREA_MISSING = 1,
    IO_FAILURE_DURING_ONLINE = 2,
    META_DATA_CORRUPTION = 3,
    MEMORY_ALLOCATION_FAILURE = 4,
    MAPPED_MEMORY_FAILURE = 5,
    COW_READ_FAILURE = 6,
    COW_WRITE_FAILURE = 7,
    DIFF_AREA_FULL = 8,
    GROW_TOO_SLOW = 9,
    GROW_FAILED = 10,
    DESTROY_ALL_SNAPSHOTS = 11,
    FILE_SYSTEM_FAILURE = 12,
    IO_FAILURE = 13,
    DIFF_AREA_REMOVED = 14,
    EXTERNAL_WRITER_TO_DIFF_AREA = 15,
    MOUNT_DURING_CLUSTER_OFFLINE = 16,
};
pub const VSS_PROTECTION_FAULT_NONE = VSS_PROTECTION_FAULT.NONE;
pub const VSS_PROTECTION_FAULT_DIFF_AREA_MISSING = VSS_PROTECTION_FAULT.DIFF_AREA_MISSING;
pub const VSS_PROTECTION_FAULT_IO_FAILURE_DURING_ONLINE = VSS_PROTECTION_FAULT.IO_FAILURE_DURING_ONLINE;
pub const VSS_PROTECTION_FAULT_META_DATA_CORRUPTION = VSS_PROTECTION_FAULT.META_DATA_CORRUPTION;
pub const VSS_PROTECTION_FAULT_MEMORY_ALLOCATION_FAILURE = VSS_PROTECTION_FAULT.MEMORY_ALLOCATION_FAILURE;
pub const VSS_PROTECTION_FAULT_MAPPED_MEMORY_FAILURE = VSS_PROTECTION_FAULT.MAPPED_MEMORY_FAILURE;
pub const VSS_PROTECTION_FAULT_COW_READ_FAILURE = VSS_PROTECTION_FAULT.COW_READ_FAILURE;
pub const VSS_PROTECTION_FAULT_COW_WRITE_FAILURE = VSS_PROTECTION_FAULT.COW_WRITE_FAILURE;
pub const VSS_PROTECTION_FAULT_DIFF_AREA_FULL = VSS_PROTECTION_FAULT.DIFF_AREA_FULL;
pub const VSS_PROTECTION_FAULT_GROW_TOO_SLOW = VSS_PROTECTION_FAULT.GROW_TOO_SLOW;
pub const VSS_PROTECTION_FAULT_GROW_FAILED = VSS_PROTECTION_FAULT.GROW_FAILED;
pub const VSS_PROTECTION_FAULT_DESTROY_ALL_SNAPSHOTS = VSS_PROTECTION_FAULT.DESTROY_ALL_SNAPSHOTS;
pub const VSS_PROTECTION_FAULT_FILE_SYSTEM_FAILURE = VSS_PROTECTION_FAULT.FILE_SYSTEM_FAILURE;
pub const VSS_PROTECTION_FAULT_IO_FAILURE = VSS_PROTECTION_FAULT.IO_FAILURE;
pub const VSS_PROTECTION_FAULT_DIFF_AREA_REMOVED = VSS_PROTECTION_FAULT.DIFF_AREA_REMOVED;
pub const VSS_PROTECTION_FAULT_EXTERNAL_WRITER_TO_DIFF_AREA = VSS_PROTECTION_FAULT.EXTERNAL_WRITER_TO_DIFF_AREA;
pub const VSS_PROTECTION_FAULT_MOUNT_DURING_CLUSTER_OFFLINE = VSS_PROTECTION_FAULT.MOUNT_DURING_CLUSTER_OFFLINE;

pub const VSS_VOLUME_PROTECTION_INFO = extern struct {
    m_protectionLevel: VSS_PROTECTION_LEVEL,
    m_volumeIsOfflineForProtection: BOOL,
    m_protectionFault: VSS_PROTECTION_FAULT,
    m_failureStatus: i32,
    m_volumeHasUnusedDiffArea: BOOL,
    m_reserved: u32,
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IVssSnapshotMgmt_Value = Guid.initString("fa7df749-66e7-4986-a27f-e2f04ae53772");
pub const IID_IVssSnapshotMgmt = &IID_IVssSnapshotMgmt_Value;
pub const IVssSnapshotMgmt = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetProviderMgmtInterface: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSnapshotMgmt,
                ProviderId: Guid,
                InterfaceId: ?*const Guid,
                ppItf: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSnapshotMgmt,
                ProviderId: Guid,
                InterfaceId: ?*const Guid,
                ppItf: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QueryVolumesSupportedForSnapshots: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSnapshotMgmt,
                ProviderId: Guid,
                lContext: i32,
                ppEnum: ?*?*IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSnapshotMgmt,
                ProviderId: Guid,
                lContext: i32,
                ppEnum: ?*?*IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QuerySnapshotsByVolume: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSnapshotMgmt,
                pwszVolumeName: ?*u16,
                ProviderId: Guid,
                ppEnum: ?*?*IVssEnumObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSnapshotMgmt,
                pwszVolumeName: ?*u16,
                ProviderId: Guid,
                ppEnum: ?*?*IVssEnumObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSnapshotMgmt_GetProviderMgmtInterface(self: *const T, ProviderId: Guid, InterfaceId: ?*const Guid, ppItf: ?*?*IUnknown) HRESULT {
                return @as(*const IVssSnapshotMgmt.VTable, @ptrCast(self.vtable)).GetProviderMgmtInterface(@as(*const IVssSnapshotMgmt, @ptrCast(self)), ProviderId, InterfaceId, ppItf);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSnapshotMgmt_QueryVolumesSupportedForSnapshots(self: *const T, ProviderId: Guid, lContext: i32, ppEnum: ?*?*IVssEnumMgmtObject) HRESULT {
                return @as(*const IVssSnapshotMgmt.VTable, @ptrCast(self.vtable)).QueryVolumesSupportedForSnapshots(@as(*const IVssSnapshotMgmt, @ptrCast(self)), ProviderId, lContext, ppEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSnapshotMgmt_QuerySnapshotsByVolume(self: *const T, pwszVolumeName: ?*u16, ProviderId: Guid, ppEnum: ?*?*IVssEnumObject) HRESULT {
                return @as(*const IVssSnapshotMgmt.VTable, @ptrCast(self.vtable)).QuerySnapshotsByVolume(@as(*const IVssSnapshotMgmt, @ptrCast(self)), pwszVolumeName, ProviderId, ppEnum);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IVssSnapshotMgmt2_Value = Guid.initString("0f61ec39-fe82-45f2-a3f0-768b5d427102");
pub const IID_IVssSnapshotMgmt2 = &IID_IVssSnapshotMgmt2_Value;
pub const IVssSnapshotMgmt2 = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetMinDiffAreaSize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSnapshotMgmt2,
                pllMinDiffAreaSize: ?*i64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSnapshotMgmt2,
                pllMinDiffAreaSize: ?*i64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSnapshotMgmt2_GetMinDiffAreaSize(self: *const T, pllMinDiffAreaSize: ?*i64) HRESULT {
                return @as(*const IVssSnapshotMgmt2.VTable, @ptrCast(self.vtable)).GetMinDiffAreaSize(@as(*const IVssSnapshotMgmt2, @ptrCast(self)), pllMinDiffAreaSize);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IVssDifferentialSoftwareSnapshotMgmt_Value = Guid.initString("214a0f28-b737-4026-b847-4f9e37d79529");
pub const IID_IVssDifferentialSoftwareSnapshotMgmt = &IID_IVssDifferentialSoftwareSnapshotMgmt_Value;
pub const IVssDifferentialSoftwareSnapshotMgmt = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        AddDiffArea: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt,
                pwszVolumeName: ?*u16,
                pwszDiffAreaVolumeName: ?*u16,
                llMaximumDiffSpace: i64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt,
                pwszVolumeName: ?*u16,
                pwszDiffAreaVolumeName: ?*u16,
                llMaximumDiffSpace: i64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ChangeDiffAreaMaximumSize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt,
                pwszVolumeName: ?*u16,
                pwszDiffAreaVolumeName: ?*u16,
                llMaximumDiffSpace: i64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt,
                pwszVolumeName: ?*u16,
                pwszDiffAreaVolumeName: ?*u16,
                llMaximumDiffSpace: i64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QueryVolumesSupportedForDiffAreas: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt,
                pwszOriginalVolumeName: ?*u16,
                ppEnum: ?*?*IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt,
                pwszOriginalVolumeName: ?*u16,
                ppEnum: ?*?*IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QueryDiffAreasForVolume: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt,
                pwszVolumeName: ?*u16,
                ppEnum: ?*?*IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt,
                pwszVolumeName: ?*u16,
                ppEnum: ?*?*IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QueryDiffAreasOnVolume: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt,
                pwszVolumeName: ?*u16,
                ppEnum: ?*?*IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt,
                pwszVolumeName: ?*u16,
                ppEnum: ?*?*IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QueryDiffAreasForSnapshot: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt,
                SnapshotId: Guid,
                ppEnum: ?*?*IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt,
                SnapshotId: Guid,
                ppEnum: ?*?*IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt_AddDiffArea(self: *const T, pwszVolumeName: ?*u16, pwszDiffAreaVolumeName: ?*u16, llMaximumDiffSpace: i64) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt.VTable, @ptrCast(self.vtable)).AddDiffArea(@as(*const IVssDifferentialSoftwareSnapshotMgmt, @ptrCast(self)), pwszVolumeName, pwszDiffAreaVolumeName, llMaximumDiffSpace);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt_ChangeDiffAreaMaximumSize(self: *const T, pwszVolumeName: ?*u16, pwszDiffAreaVolumeName: ?*u16, llMaximumDiffSpace: i64) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt.VTable, @ptrCast(self.vtable)).ChangeDiffAreaMaximumSize(@as(*const IVssDifferentialSoftwareSnapshotMgmt, @ptrCast(self)), pwszVolumeName, pwszDiffAreaVolumeName, llMaximumDiffSpace);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt_QueryVolumesSupportedForDiffAreas(self: *const T, pwszOriginalVolumeName: ?*u16, ppEnum: ?*?*IVssEnumMgmtObject) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt.VTable, @ptrCast(self.vtable)).QueryVolumesSupportedForDiffAreas(@as(*const IVssDifferentialSoftwareSnapshotMgmt, @ptrCast(self)), pwszOriginalVolumeName, ppEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt_QueryDiffAreasForVolume(self: *const T, pwszVolumeName: ?*u16, ppEnum: ?*?*IVssEnumMgmtObject) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt.VTable, @ptrCast(self.vtable)).QueryDiffAreasForVolume(@as(*const IVssDifferentialSoftwareSnapshotMgmt, @ptrCast(self)), pwszVolumeName, ppEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt_QueryDiffAreasOnVolume(self: *const T, pwszVolumeName: ?*u16, ppEnum: ?*?*IVssEnumMgmtObject) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt.VTable, @ptrCast(self.vtable)).QueryDiffAreasOnVolume(@as(*const IVssDifferentialSoftwareSnapshotMgmt, @ptrCast(self)), pwszVolumeName, ppEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt_QueryDiffAreasForSnapshot(self: *const T, SnapshotId: Guid, ppEnum: ?*?*IVssEnumMgmtObject) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt.VTable, @ptrCast(self.vtable)).QueryDiffAreasForSnapshot(@as(*const IVssDifferentialSoftwareSnapshotMgmt, @ptrCast(self)), SnapshotId, ppEnum);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IVssDifferentialSoftwareSnapshotMgmt2_Value = Guid.initString("949d7353-675f-4275-8969-f044c6277815");
pub const IID_IVssDifferentialSoftwareSnapshotMgmt2 = &IID_IVssDifferentialSoftwareSnapshotMgmt2_Value;
pub const IVssDifferentialSoftwareSnapshotMgmt2 = extern struct {
    pub const VTable = extern struct {
        base: IVssDifferentialSoftwareSnapshotMgmt.VTable,
        ChangeDiffAreaMaximumSizeEx: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt2,
                pwszVolumeName: ?*u16,
                pwszDiffAreaVolumeName: ?*u16,
                llMaximumDiffSpace: i64,
                bVolatile: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt2,
                pwszVolumeName: ?*u16,
                pwszDiffAreaVolumeName: ?*u16,
                llMaximumDiffSpace: i64,
                bVolatile: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MigrateDiffAreas: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt2,
                pwszVolumeName: ?*u16,
                pwszDiffAreaVolumeName: ?*u16,
                pwszNewDiffAreaVolumeName: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt2,
                pwszVolumeName: ?*u16,
                pwszDiffAreaVolumeName: ?*u16,
                pwszNewDiffAreaVolumeName: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QueryMigrationStatus: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt2,
                pwszVolumeName: ?*u16,
                pwszDiffAreaVolumeName: ?*u16,
                ppAsync: ?*?*IVssAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt2,
                pwszVolumeName: ?*u16,
                pwszDiffAreaVolumeName: ?*u16,
                ppAsync: ?*?*IVssAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetSnapshotPriority: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt2,
                idSnapshot: Guid,
                priority: u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt2,
                idSnapshot: Guid,
                priority: u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IVssDifferentialSoftwareSnapshotMgmt.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt2_ChangeDiffAreaMaximumSizeEx(self: *const T, pwszVolumeName: ?*u16, pwszDiffAreaVolumeName: ?*u16, llMaximumDiffSpace: i64, bVolatile: BOOL) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt2.VTable, @ptrCast(self.vtable)).ChangeDiffAreaMaximumSizeEx(@as(*const IVssDifferentialSoftwareSnapshotMgmt2, @ptrCast(self)), pwszVolumeName, pwszDiffAreaVolumeName, llMaximumDiffSpace, bVolatile);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt2_MigrateDiffAreas(self: *const T, pwszVolumeName: ?*u16, pwszDiffAreaVolumeName: ?*u16, pwszNewDiffAreaVolumeName: ?*u16) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt2.VTable, @ptrCast(self.vtable)).MigrateDiffAreas(@as(*const IVssDifferentialSoftwareSnapshotMgmt2, @ptrCast(self)), pwszVolumeName, pwszDiffAreaVolumeName, pwszNewDiffAreaVolumeName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt2_QueryMigrationStatus(self: *const T, pwszVolumeName: ?*u16, pwszDiffAreaVolumeName: ?*u16, ppAsync: ?*?*IVssAsync) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt2.VTable, @ptrCast(self.vtable)).QueryMigrationStatus(@as(*const IVssDifferentialSoftwareSnapshotMgmt2, @ptrCast(self)), pwszVolumeName, pwszDiffAreaVolumeName, ppAsync);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt2_SetSnapshotPriority(self: *const T, idSnapshot: Guid, priority: u8) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt2.VTable, @ptrCast(self.vtable)).SetSnapshotPriority(@as(*const IVssDifferentialSoftwareSnapshotMgmt2, @ptrCast(self)), idSnapshot, priority);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IVssDifferentialSoftwareSnapshotMgmt3_Value = Guid.initString("383f7e71-a4c5-401f-b27f-f826289f8458");
pub const IID_IVssDifferentialSoftwareSnapshotMgmt3 = &IID_IVssDifferentialSoftwareSnapshotMgmt3_Value;
pub const IVssDifferentialSoftwareSnapshotMgmt3 = extern struct {
    pub const VTable = extern struct {
        base: IVssDifferentialSoftwareSnapshotMgmt2.VTable,
        SetVolumeProtectLevel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt3,
                pwszVolumeName: ?*u16,
                protectionLevel: VSS_PROTECTION_LEVEL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt3,
                pwszVolumeName: ?*u16,
                protectionLevel: VSS_PROTECTION_LEVEL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetVolumeProtectLevel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt3,
                pwszVolumeName: ?*u16,
                protectionLevel: ?*VSS_VOLUME_PROTECTION_INFO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt3,
                pwszVolumeName: ?*u16,
                protectionLevel: ?*VSS_VOLUME_PROTECTION_INFO,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ClearVolumeProtectFault: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt3,
                pwszVolumeName: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt3,
                pwszVolumeName: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DeleteUnusedDiffAreas: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt3,
                pwszDiffAreaVolumeName: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt3,
                pwszDiffAreaVolumeName: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QuerySnapshotDeltaBitmap: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt3,
                idSnapshotOlder: Guid,
                idSnapshotYounger: Guid,
                pcBlockSizePerBit: ?*u32,
                pcBitmapLength: ?*u32,
                ppbBitmap: [*]?*u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssDifferentialSoftwareSnapshotMgmt3,
                idSnapshotOlder: Guid,
                idSnapshotYounger: Guid,
                pcBlockSizePerBit: ?*u32,
                pcBitmapLength: ?*u32,
                ppbBitmap: [*]?*u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IVssDifferentialSoftwareSnapshotMgmt2.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt3_SetVolumeProtectLevel(self: *const T, pwszVolumeName: ?*u16, protectionLevel: VSS_PROTECTION_LEVEL) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt3.VTable, @ptrCast(self.vtable)).SetVolumeProtectLevel(@as(*const IVssDifferentialSoftwareSnapshotMgmt3, @ptrCast(self)), pwszVolumeName, protectionLevel);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt3_GetVolumeProtectLevel(self: *const T, pwszVolumeName: ?*u16, protectionLevel: ?*VSS_VOLUME_PROTECTION_INFO) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt3.VTable, @ptrCast(self.vtable)).GetVolumeProtectLevel(@as(*const IVssDifferentialSoftwareSnapshotMgmt3, @ptrCast(self)), pwszVolumeName, protectionLevel);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt3_ClearVolumeProtectFault(self: *const T, pwszVolumeName: ?*u16) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt3.VTable, @ptrCast(self.vtable)).ClearVolumeProtectFault(@as(*const IVssDifferentialSoftwareSnapshotMgmt3, @ptrCast(self)), pwszVolumeName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt3_DeleteUnusedDiffAreas(self: *const T, pwszDiffAreaVolumeName: ?*u16) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt3.VTable, @ptrCast(self.vtable)).DeleteUnusedDiffAreas(@as(*const IVssDifferentialSoftwareSnapshotMgmt3, @ptrCast(self)), pwszDiffAreaVolumeName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssDifferentialSoftwareSnapshotMgmt3_QuerySnapshotDeltaBitmap(self: *const T, idSnapshotOlder: Guid, idSnapshotYounger: Guid, pcBlockSizePerBit: ?*u32, pcBitmapLength: ?*u32, ppbBitmap: [*]?*u8) HRESULT {
                return @as(*const IVssDifferentialSoftwareSnapshotMgmt3.VTable, @ptrCast(self.vtable)).QuerySnapshotDeltaBitmap(@as(*const IVssDifferentialSoftwareSnapshotMgmt3, @ptrCast(self)), idSnapshotOlder, idSnapshotYounger, pcBlockSizePerBit, pcBitmapLength, ppbBitmap);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IVssEnumMgmtObject_Value = Guid.initString("01954e6b-9254-4e6e-808c-c9e05d007696");
pub const IID_IVssEnumMgmtObject = &IID_IVssEnumMgmtObject_Value;
pub const IVssEnumMgmtObject = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Next: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssEnumMgmtObject,
                celt: u32,
                rgelt: [*]VSS_MGMT_OBJECT_PROP,
                pceltFetched: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssEnumMgmtObject,
                celt: u32,
                rgelt: [*]VSS_MGMT_OBJECT_PROP,
                pceltFetched: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Skip: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssEnumMgmtObject,
                celt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssEnumMgmtObject,
                celt: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Clone: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssEnumMgmtObject,
                ppenum: ?*?*IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssEnumMgmtObject,
                ppenum: ?*?*IVssEnumMgmtObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssEnumMgmtObject_Next(self: *const T, celt: u32, rgelt: [*]VSS_MGMT_OBJECT_PROP, pceltFetched: ?*u32) HRESULT {
                return @as(*const IVssEnumMgmtObject.VTable, @ptrCast(self.vtable)).Next(@as(*const IVssEnumMgmtObject, @ptrCast(self)), celt, rgelt, pceltFetched);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssEnumMgmtObject_Skip(self: *const T, celt: u32) HRESULT {
                return @as(*const IVssEnumMgmtObject.VTable, @ptrCast(self.vtable)).Skip(@as(*const IVssEnumMgmtObject, @ptrCast(self)), celt);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssEnumMgmtObject_Reset(self: *const T) HRESULT {
                return @as(*const IVssEnumMgmtObject.VTable, @ptrCast(self.vtable)).Reset(@as(*const IVssEnumMgmtObject, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssEnumMgmtObject_Clone(self: *const T, ppenum: ?*?*IVssEnumMgmtObject) HRESULT {
                return @as(*const IVssEnumMgmtObject.VTable, @ptrCast(self.vtable)).Clone(@as(*const IVssEnumMgmtObject, @ptrCast(self)), ppenum);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const CLSID_VSSCoordinator_Value = Guid.initString("e579ab5f-1cc4-44b4-bed9-de0991ff0623");
pub const CLSID_VSSCoordinator = &CLSID_VSSCoordinator_Value;

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IVssAdmin_Value = Guid.initString("77ed5996-2f63-11d3-8a39-00c04f72d8e3");
pub const IID_IVssAdmin = &IID_IVssAdmin_Value;
pub const IVssAdmin = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        RegisterProvider: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssAdmin,
                pProviderId: Guid,
                ClassId: Guid,
                pwszProviderName: ?*u16,
                eProviderType: VSS_PROVIDER_TYPE,
                pwszProviderVersion: ?*u16,
                ProviderVersionId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssAdmin,
                pProviderId: Guid,
                ClassId: Guid,
                pwszProviderName: ?*u16,
                eProviderType: VSS_PROVIDER_TYPE,
                pwszProviderVersion: ?*u16,
                ProviderVersionId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        UnregisterProvider: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssAdmin,
                ProviderId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssAdmin,
                ProviderId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QueryProviders: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssAdmin,
                ppEnum: ?*?*IVssEnumObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssAdmin,
                ppEnum: ?*?*IVssEnumObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AbortAllSnapshotsInProgress: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssAdmin,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssAdmin,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssAdmin_RegisterProvider(self: *const T, pProviderId: Guid, ClassId: Guid, pwszProviderName: ?*u16, eProviderType: VSS_PROVIDER_TYPE, pwszProviderVersion: ?*u16, ProviderVersionId: Guid) HRESULT {
                return @as(*const IVssAdmin.VTable, @ptrCast(self.vtable)).RegisterProvider(@as(*const IVssAdmin, @ptrCast(self)), pProviderId, ClassId, pwszProviderName, eProviderType, pwszProviderVersion, ProviderVersionId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssAdmin_UnregisterProvider(self: *const T, ProviderId: Guid) HRESULT {
                return @as(*const IVssAdmin.VTable, @ptrCast(self.vtable)).UnregisterProvider(@as(*const IVssAdmin, @ptrCast(self)), ProviderId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssAdmin_QueryProviders(self: *const T, ppEnum: ?*?*IVssEnumObject) HRESULT {
                return @as(*const IVssAdmin.VTable, @ptrCast(self.vtable)).QueryProviders(@as(*const IVssAdmin, @ptrCast(self)), ppEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssAdmin_AbortAllSnapshotsInProgress(self: *const T) HRESULT {
                return @as(*const IVssAdmin.VTable, @ptrCast(self.vtable)).AbortAllSnapshotsInProgress(@as(*const IVssAdmin, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IVssAdminEx_Value = Guid.initString("7858a9f8-b1fa-41a6-964f-b9b36b8cd8d8");
pub const IID_IVssAdminEx = &IID_IVssAdminEx_Value;
pub const IVssAdminEx = extern struct {
    pub const VTable = extern struct {
        base: IVssAdmin.VTable,
        GetProviderCapability: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssAdminEx,
                pProviderId: Guid,
                pllOriginalCapabilityMask: ?*u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssAdminEx,
                pProviderId: Guid,
                pllOriginalCapabilityMask: ?*u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetProviderContext: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssAdminEx,
                ProviderId: Guid,
                plContext: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssAdminEx,
                ProviderId: Guid,
                plContext: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetProviderContext: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssAdminEx,
                ProviderId: Guid,
                lContext: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssAdminEx,
                ProviderId: Guid,
                lContext: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IVssAdmin.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssAdminEx_GetProviderCapability(self: *const T, pProviderId: Guid, pllOriginalCapabilityMask: ?*u64) HRESULT {
                return @as(*const IVssAdminEx.VTable, @ptrCast(self.vtable)).GetProviderCapability(@as(*const IVssAdminEx, @ptrCast(self)), pProviderId, pllOriginalCapabilityMask);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssAdminEx_GetProviderContext(self: *const T, ProviderId: Guid, plContext: ?*i32) HRESULT {
                return @as(*const IVssAdminEx.VTable, @ptrCast(self.vtable)).GetProviderContext(@as(*const IVssAdminEx, @ptrCast(self)), ProviderId, plContext);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssAdminEx_SetProviderContext(self: *const T, ProviderId: Guid, lContext: i32) HRESULT {
                return @as(*const IVssAdminEx.VTable, @ptrCast(self.vtable)).SetProviderContext(@as(*const IVssAdminEx, @ptrCast(self)), ProviderId, lContext);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IVssSoftwareSnapshotProvider_Value = Guid.initString("609e123e-2c5a-44d3-8f01-0b1d9a47d1ff");
pub const IID_IVssSoftwareSnapshotProvider = &IID_IVssSoftwareSnapshotProvider_Value;
pub const IVssSoftwareSnapshotProvider = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetContext: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSoftwareSnapshotProvider,
                lContext: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSoftwareSnapshotProvider,
                lContext: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSnapshotProperties: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSoftwareSnapshotProvider,
                SnapshotId: Guid,
                pProp: ?*VSS_SNAPSHOT_PROP,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSoftwareSnapshotProvider,
                SnapshotId: Guid,
                pProp: ?*VSS_SNAPSHOT_PROP,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Query: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSoftwareSnapshotProvider,
                QueriedObjectId: Guid,
                eQueriedObjectType: VSS_OBJECT_TYPE,
                eReturnedObjectsType: VSS_OBJECT_TYPE,
                ppEnum: ?*?*IVssEnumObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSoftwareSnapshotProvider,
                QueriedObjectId: Guid,
                eQueriedObjectType: VSS_OBJECT_TYPE,
                eReturnedObjectsType: VSS_OBJECT_TYPE,
                ppEnum: ?*?*IVssEnumObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DeleteSnapshots: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSoftwareSnapshotProvider,
                SourceObjectId: Guid,
                eSourceObjectType: VSS_OBJECT_TYPE,
                bForceDelete: BOOL,
                plDeletedSnapshots: ?*i32,
                pNondeletedSnapshotID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSoftwareSnapshotProvider,
                SourceObjectId: Guid,
                eSourceObjectType: VSS_OBJECT_TYPE,
                bForceDelete: BOOL,
                plDeletedSnapshots: ?*i32,
                pNondeletedSnapshotID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BeginPrepareSnapshot: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSoftwareSnapshotProvider,
                SnapshotSetId: Guid,
                SnapshotId: Guid,
                pwszVolumeName: ?*u16,
                lNewContext: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSoftwareSnapshotProvider,
                SnapshotSetId: Guid,
                SnapshotId: Guid,
                pwszVolumeName: ?*u16,
                lNewContext: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsVolumeSupported: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSoftwareSnapshotProvider,
                pwszVolumeName: ?*u16,
                pbSupportedByThisProvider: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSoftwareSnapshotProvider,
                pwszVolumeName: ?*u16,
                pbSupportedByThisProvider: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsVolumeSnapshotted: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSoftwareSnapshotProvider,
                pwszVolumeName: ?*u16,
                pbSnapshotsPresent: ?*BOOL,
                plSnapshotCompatibility: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSoftwareSnapshotProvider,
                pwszVolumeName: ?*u16,
                pbSnapshotsPresent: ?*BOOL,
                plSnapshotCompatibility: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetSnapshotProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSoftwareSnapshotProvider,
                SnapshotId: Guid,
                eSnapshotPropertyId: VSS_SNAPSHOT_PROPERTY_ID,
                vProperty: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSoftwareSnapshotProvider,
                SnapshotId: Guid,
                eSnapshotPropertyId: VSS_SNAPSHOT_PROPERTY_ID,
                vProperty: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RevertToSnapshot: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSoftwareSnapshotProvider,
                SnapshotId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSoftwareSnapshotProvider,
                SnapshotId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QueryRevertStatus: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssSoftwareSnapshotProvider,
                pwszVolume: ?*u16,
                ppAsync: ?*?*IVssAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssSoftwareSnapshotProvider,
                pwszVolume: ?*u16,
                ppAsync: ?*?*IVssAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSoftwareSnapshotProvider_SetContext(self: *const T, lContext: i32) HRESULT {
                return @as(*const IVssSoftwareSnapshotProvider.VTable, @ptrCast(self.vtable)).SetContext(@as(*const IVssSoftwareSnapshotProvider, @ptrCast(self)), lContext);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSoftwareSnapshotProvider_GetSnapshotProperties(self: *const T, SnapshotId: Guid, pProp: ?*VSS_SNAPSHOT_PROP) HRESULT {
                return @as(*const IVssSoftwareSnapshotProvider.VTable, @ptrCast(self.vtable)).GetSnapshotProperties(@as(*const IVssSoftwareSnapshotProvider, @ptrCast(self)), SnapshotId, pProp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSoftwareSnapshotProvider_Query(self: *const T, QueriedObjectId: Guid, eQueriedObjectType: VSS_OBJECT_TYPE, eReturnedObjectsType: VSS_OBJECT_TYPE, ppEnum: ?*?*IVssEnumObject) HRESULT {
                return @as(*const IVssSoftwareSnapshotProvider.VTable, @ptrCast(self.vtable)).Query(@as(*const IVssSoftwareSnapshotProvider, @ptrCast(self)), QueriedObjectId, eQueriedObjectType, eReturnedObjectsType, ppEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSoftwareSnapshotProvider_DeleteSnapshots(self: *const T, SourceObjectId: Guid, eSourceObjectType: VSS_OBJECT_TYPE, bForceDelete: BOOL, plDeletedSnapshots: ?*i32, pNondeletedSnapshotID: ?*Guid) HRESULT {
                return @as(*const IVssSoftwareSnapshotProvider.VTable, @ptrCast(self.vtable)).DeleteSnapshots(@as(*const IVssSoftwareSnapshotProvider, @ptrCast(self)), SourceObjectId, eSourceObjectType, bForceDelete, plDeletedSnapshots, pNondeletedSnapshotID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSoftwareSnapshotProvider_BeginPrepareSnapshot(self: *const T, SnapshotSetId: Guid, SnapshotId: Guid, pwszVolumeName: ?*u16, lNewContext: i32) HRESULT {
                return @as(*const IVssSoftwareSnapshotProvider.VTable, @ptrCast(self.vtable)).BeginPrepareSnapshot(@as(*const IVssSoftwareSnapshotProvider, @ptrCast(self)), SnapshotSetId, SnapshotId, pwszVolumeName, lNewContext);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSoftwareSnapshotProvider_IsVolumeSupported(self: *const T, pwszVolumeName: ?*u16, pbSupportedByThisProvider: ?*BOOL) HRESULT {
                return @as(*const IVssSoftwareSnapshotProvider.VTable, @ptrCast(self.vtable)).IsVolumeSupported(@as(*const IVssSoftwareSnapshotProvider, @ptrCast(self)), pwszVolumeName, pbSupportedByThisProvider);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSoftwareSnapshotProvider_IsVolumeSnapshotted(self: *const T, pwszVolumeName: ?*u16, pbSnapshotsPresent: ?*BOOL, plSnapshotCompatibility: ?*i32) HRESULT {
                return @as(*const IVssSoftwareSnapshotProvider.VTable, @ptrCast(self.vtable)).IsVolumeSnapshotted(@as(*const IVssSoftwareSnapshotProvider, @ptrCast(self)), pwszVolumeName, pbSnapshotsPresent, plSnapshotCompatibility);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSoftwareSnapshotProvider_SetSnapshotProperty(self: *const T, SnapshotId: Guid, eSnapshotPropertyId: VSS_SNAPSHOT_PROPERTY_ID, vProperty: VARIANT) HRESULT {
                return @as(*const IVssSoftwareSnapshotProvider.VTable, @ptrCast(self.vtable)).SetSnapshotProperty(@as(*const IVssSoftwareSnapshotProvider, @ptrCast(self)), SnapshotId, eSnapshotPropertyId, vProperty);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSoftwareSnapshotProvider_RevertToSnapshot(self: *const T, SnapshotId: Guid) HRESULT {
                return @as(*const IVssSoftwareSnapshotProvider.VTable, @ptrCast(self.vtable)).RevertToSnapshot(@as(*const IVssSoftwareSnapshotProvider, @ptrCast(self)), SnapshotId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssSoftwareSnapshotProvider_QueryRevertStatus(self: *const T, pwszVolume: ?*u16, ppAsync: ?*?*IVssAsync) HRESULT {
                return @as(*const IVssSoftwareSnapshotProvider.VTable, @ptrCast(self.vtable)).QueryRevertStatus(@as(*const IVssSoftwareSnapshotProvider, @ptrCast(self)), pwszVolume, ppAsync);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IVssProviderCreateSnapshotSet_Value = Guid.initString("5f894e5b-1e39-4778-8e23-9abad9f0e08c");
pub const IID_IVssProviderCreateSnapshotSet = &IID_IVssProviderCreateSnapshotSet_Value;
pub const IVssProviderCreateSnapshotSet = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        EndPrepareSnapshots: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PreCommitSnapshots: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CommitSnapshots: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PostCommitSnapshots: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
                lSnapshotsCount: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
                lSnapshotsCount: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PreFinalCommitSnapshots: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        PostFinalCommitSnapshots: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AbortSnapshots: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssProviderCreateSnapshotSet,
                SnapshotSetId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssProviderCreateSnapshotSet_EndPrepareSnapshots(self: *const T, SnapshotSetId: Guid) HRESULT {
                return @as(*const IVssProviderCreateSnapshotSet.VTable, @ptrCast(self.vtable)).EndPrepareSnapshots(@as(*const IVssProviderCreateSnapshotSet, @ptrCast(self)), SnapshotSetId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssProviderCreateSnapshotSet_PreCommitSnapshots(self: *const T, SnapshotSetId: Guid) HRESULT {
                return @as(*const IVssProviderCreateSnapshotSet.VTable, @ptrCast(self.vtable)).PreCommitSnapshots(@as(*const IVssProviderCreateSnapshotSet, @ptrCast(self)), SnapshotSetId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssProviderCreateSnapshotSet_CommitSnapshots(self: *const T, SnapshotSetId: Guid) HRESULT {
                return @as(*const IVssProviderCreateSnapshotSet.VTable, @ptrCast(self.vtable)).CommitSnapshots(@as(*const IVssProviderCreateSnapshotSet, @ptrCast(self)), SnapshotSetId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssProviderCreateSnapshotSet_PostCommitSnapshots(self: *const T, SnapshotSetId: Guid, lSnapshotsCount: i32) HRESULT {
                return @as(*const IVssProviderCreateSnapshotSet.VTable, @ptrCast(self.vtable)).PostCommitSnapshots(@as(*const IVssProviderCreateSnapshotSet, @ptrCast(self)), SnapshotSetId, lSnapshotsCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssProviderCreateSnapshotSet_PreFinalCommitSnapshots(self: *const T, SnapshotSetId: Guid) HRESULT {
                return @as(*const IVssProviderCreateSnapshotSet.VTable, @ptrCast(self.vtable)).PreFinalCommitSnapshots(@as(*const IVssProviderCreateSnapshotSet, @ptrCast(self)), SnapshotSetId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssProviderCreateSnapshotSet_PostFinalCommitSnapshots(self: *const T, SnapshotSetId: Guid) HRESULT {
                return @as(*const IVssProviderCreateSnapshotSet.VTable, @ptrCast(self.vtable)).PostFinalCommitSnapshots(@as(*const IVssProviderCreateSnapshotSet, @ptrCast(self)), SnapshotSetId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssProviderCreateSnapshotSet_AbortSnapshots(self: *const T, SnapshotSetId: Guid) HRESULT {
                return @as(*const IVssProviderCreateSnapshotSet.VTable, @ptrCast(self.vtable)).AbortSnapshots(@as(*const IVssProviderCreateSnapshotSet, @ptrCast(self)), SnapshotSetId);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IVssProviderNotifications_Value = Guid.initString("e561901f-03a5-4afe-86d0-72baeece7004");
pub const IID_IVssProviderNotifications = &IID_IVssProviderNotifications_Value;
pub const IVssProviderNotifications = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnLoad: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssProviderNotifications,
                pCallback: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssProviderNotifications,
                pCallback: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnUnload: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssProviderNotifications,
                bForceUnload: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssProviderNotifications,
                bForceUnload: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssProviderNotifications_OnLoad(self: *const T, pCallback: ?*IUnknown) HRESULT {
                return @as(*const IVssProviderNotifications.VTable, @ptrCast(self.vtable)).OnLoad(@as(*const IVssProviderNotifications, @ptrCast(self)), pCallback);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssProviderNotifications_OnUnload(self: *const T, bForceUnload: BOOL) HRESULT {
                return @as(*const IVssProviderNotifications.VTable, @ptrCast(self.vtable)).OnUnload(@as(*const IVssProviderNotifications, @ptrCast(self)), bForceUnload);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windowsServer2003'
const IID_IVssHardwareSnapshotProvider_Value = Guid.initString("9593a157-44e9-4344-bbeb-44fbf9b06b10");
pub const IID_IVssHardwareSnapshotProvider = &IID_IVssHardwareSnapshotProvider_Value;
pub const IVssHardwareSnapshotProvider = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        AreLunsSupported: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssHardwareSnapshotProvider,
                lLunCount: i32,
                lContext: i32,
                rgwszDevices: [*]?*u16,
                pLunInformation: [*]VDS_LUN_INFORMATION,
                pbIsSupported: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssHardwareSnapshotProvider,
                lLunCount: i32,
                lContext: i32,
                rgwszDevices: [*]?*u16,
                pLunInformation: [*]VDS_LUN_INFORMATION,
                pbIsSupported: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FillInLunInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssHardwareSnapshotProvider,
                wszDeviceName: ?*u16,
                pLunInfo: ?*VDS_LUN_INFORMATION,
                pbIsSupported: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssHardwareSnapshotProvider,
                wszDeviceName: ?*u16,
                pLunInfo: ?*VDS_LUN_INFORMATION,
                pbIsSupported: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BeginPrepareSnapshot: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssHardwareSnapshotProvider,
                SnapshotSetId: Guid,
                SnapshotId: Guid,
                lContext: i32,
                lLunCount: i32,
                rgDeviceNames: [*]?*u16,
                rgLunInformation: [*]VDS_LUN_INFORMATION,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssHardwareSnapshotProvider,
                SnapshotSetId: Guid,
                SnapshotId: Guid,
                lContext: i32,
                lLunCount: i32,
                rgDeviceNames: [*]?*u16,
                rgLunInformation: [*]VDS_LUN_INFORMATION,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetTargetLuns: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssHardwareSnapshotProvider,
                lLunCount: i32,
                rgDeviceNames: [*]?*u16,
                rgSourceLuns: [*]VDS_LUN_INFORMATION,
                rgDestinationLuns: [*]VDS_LUN_INFORMATION,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssHardwareSnapshotProvider,
                lLunCount: i32,
                rgDeviceNames: [*]?*u16,
                rgSourceLuns: [*]VDS_LUN_INFORMATION,
                rgDestinationLuns: [*]VDS_LUN_INFORMATION,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        LocateLuns: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssHardwareSnapshotProvider,
                lLunCount: i32,
                rgSourceLuns: [*]VDS_LUN_INFORMATION,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssHardwareSnapshotProvider,
                lLunCount: i32,
                rgSourceLuns: [*]VDS_LUN_INFORMATION,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnLunEmpty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssHardwareSnapshotProvider,
                wszDeviceName: ?*u16,
                pInformation: ?*VDS_LUN_INFORMATION,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssHardwareSnapshotProvider,
                wszDeviceName: ?*u16,
                pInformation: ?*VDS_LUN_INFORMATION,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssHardwareSnapshotProvider_AreLunsSupported(self: *const T, lLunCount: i32, lContext: i32, rgwszDevices: [*]?*u16, pLunInformation: [*]VDS_LUN_INFORMATION, pbIsSupported: ?*BOOL) HRESULT {
                return @as(*const IVssHardwareSnapshotProvider.VTable, @ptrCast(self.vtable)).AreLunsSupported(@as(*const IVssHardwareSnapshotProvider, @ptrCast(self)), lLunCount, lContext, rgwszDevices, pLunInformation, pbIsSupported);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssHardwareSnapshotProvider_FillInLunInfo(self: *const T, wszDeviceName: ?*u16, pLunInfo: ?*VDS_LUN_INFORMATION, pbIsSupported: ?*BOOL) HRESULT {
                return @as(*const IVssHardwareSnapshotProvider.VTable, @ptrCast(self.vtable)).FillInLunInfo(@as(*const IVssHardwareSnapshotProvider, @ptrCast(self)), wszDeviceName, pLunInfo, pbIsSupported);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssHardwareSnapshotProvider_BeginPrepareSnapshot(self: *const T, SnapshotSetId: Guid, SnapshotId: Guid, lContext: i32, lLunCount: i32, rgDeviceNames: [*]?*u16, rgLunInformation: [*]VDS_LUN_INFORMATION) HRESULT {
                return @as(*const IVssHardwareSnapshotProvider.VTable, @ptrCast(self.vtable)).BeginPrepareSnapshot(@as(*const IVssHardwareSnapshotProvider, @ptrCast(self)), SnapshotSetId, SnapshotId, lContext, lLunCount, rgDeviceNames, rgLunInformation);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssHardwareSnapshotProvider_GetTargetLuns(self: *const T, lLunCount: i32, rgDeviceNames: [*]?*u16, rgSourceLuns: [*]VDS_LUN_INFORMATION, rgDestinationLuns: [*]VDS_LUN_INFORMATION) HRESULT {
                return @as(*const IVssHardwareSnapshotProvider.VTable, @ptrCast(self.vtable)).GetTargetLuns(@as(*const IVssHardwareSnapshotProvider, @ptrCast(self)), lLunCount, rgDeviceNames, rgSourceLuns, rgDestinationLuns);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssHardwareSnapshotProvider_LocateLuns(self: *const T, lLunCount: i32, rgSourceLuns: [*]VDS_LUN_INFORMATION) HRESULT {
                return @as(*const IVssHardwareSnapshotProvider.VTable, @ptrCast(self.vtable)).LocateLuns(@as(*const IVssHardwareSnapshotProvider, @ptrCast(self)), lLunCount, rgSourceLuns);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssHardwareSnapshotProvider_OnLunEmpty(self: *const T, wszDeviceName: ?*u16, pInformation: ?*VDS_LUN_INFORMATION) HRESULT {
                return @as(*const IVssHardwareSnapshotProvider.VTable, @ptrCast(self.vtable)).OnLunEmpty(@as(*const IVssHardwareSnapshotProvider, @ptrCast(self)), wszDeviceName, pInformation);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windowsServer2008'
const IID_IVssHardwareSnapshotProviderEx_Value = Guid.initString("7f5ba925-cdb1-4d11-a71f-339eb7e709fd");
pub const IID_IVssHardwareSnapshotProviderEx = &IID_IVssHardwareSnapshotProviderEx_Value;
pub const IVssHardwareSnapshotProviderEx = extern struct {
    pub const VTable = extern struct {
        base: IVssHardwareSnapshotProvider.VTable,
        GetProviderCapabilities: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssHardwareSnapshotProviderEx,
                pllOriginalCapabilityMask: ?*u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssHardwareSnapshotProviderEx,
                pllOriginalCapabilityMask: ?*u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnLunStateChange: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssHardwareSnapshotProviderEx,
                pSnapshotLuns: [*]VDS_LUN_INFORMATION,
                pOriginalLuns: [*]VDS_LUN_INFORMATION,
                dwCount: u32,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssHardwareSnapshotProviderEx,
                pSnapshotLuns: [*]VDS_LUN_INFORMATION,
                pOriginalLuns: [*]VDS_LUN_INFORMATION,
                dwCount: u32,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ResyncLuns: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssHardwareSnapshotProviderEx,
                pSourceLuns: [*]VDS_LUN_INFORMATION,
                pTargetLuns: [*]VDS_LUN_INFORMATION,
                dwCount: u32,
                ppAsync: ?*?*IVssAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssHardwareSnapshotProviderEx,
                pSourceLuns: [*]VDS_LUN_INFORMATION,
                pTargetLuns: [*]VDS_LUN_INFORMATION,
                dwCount: u32,
                ppAsync: ?*?*IVssAsync,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnReuseLuns: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssHardwareSnapshotProviderEx,
                pSnapshotLuns: [*]VDS_LUN_INFORMATION,
                pOriginalLuns: [*]VDS_LUN_INFORMATION,
                dwCount: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssHardwareSnapshotProviderEx,
                pSnapshotLuns: [*]VDS_LUN_INFORMATION,
                pOriginalLuns: [*]VDS_LUN_INFORMATION,
                dwCount: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IVssHardwareSnapshotProvider.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssHardwareSnapshotProviderEx_GetProviderCapabilities(self: *const T, pllOriginalCapabilityMask: ?*u64) HRESULT {
                return @as(*const IVssHardwareSnapshotProviderEx.VTable, @ptrCast(self.vtable)).GetProviderCapabilities(@as(*const IVssHardwareSnapshotProviderEx, @ptrCast(self)), pllOriginalCapabilityMask);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssHardwareSnapshotProviderEx_OnLunStateChange(self: *const T, pSnapshotLuns: [*]VDS_LUN_INFORMATION, pOriginalLuns: [*]VDS_LUN_INFORMATION, dwCount: u32, dwFlags: u32) HRESULT {
                return @as(*const IVssHardwareSnapshotProviderEx.VTable, @ptrCast(self.vtable)).OnLunStateChange(@as(*const IVssHardwareSnapshotProviderEx, @ptrCast(self)), pSnapshotLuns, pOriginalLuns, dwCount, dwFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssHardwareSnapshotProviderEx_ResyncLuns(self: *const T, pSourceLuns: [*]VDS_LUN_INFORMATION, pTargetLuns: [*]VDS_LUN_INFORMATION, dwCount: u32, ppAsync: ?*?*IVssAsync) HRESULT {
                return @as(*const IVssHardwareSnapshotProviderEx.VTable, @ptrCast(self.vtable)).ResyncLuns(@as(*const IVssHardwareSnapshotProviderEx, @ptrCast(self)), pSourceLuns, pTargetLuns, dwCount, ppAsync);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssHardwareSnapshotProviderEx_OnReuseLuns(self: *const T, pSnapshotLuns: [*]VDS_LUN_INFORMATION, pOriginalLuns: [*]VDS_LUN_INFORMATION, dwCount: u32) HRESULT {
                return @as(*const IVssHardwareSnapshotProviderEx.VTable, @ptrCast(self.vtable)).OnReuseLuns(@as(*const IVssHardwareSnapshotProviderEx, @ptrCast(self)), pSnapshotLuns, pOriginalLuns, dwCount);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows8.1'
const IID_IVssFileShareSnapshotProvider_Value = Guid.initString("c8636060-7c2e-11df-8c4a-0800200c9a66");
pub const IID_IVssFileShareSnapshotProvider = &IID_IVssFileShareSnapshotProvider_Value;
pub const IVssFileShareSnapshotProvider = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetContext: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssFileShareSnapshotProvider,
                lContext: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssFileShareSnapshotProvider,
                lContext: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSnapshotProperties: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssFileShareSnapshotProvider,
                SnapshotId: Guid,
                pProp: ?*VSS_SNAPSHOT_PROP,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssFileShareSnapshotProvider,
                SnapshotId: Guid,
                pProp: ?*VSS_SNAPSHOT_PROP,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Query: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssFileShareSnapshotProvider,
                QueriedObjectId: Guid,
                eQueriedObjectType: VSS_OBJECT_TYPE,
                eReturnedObjectsType: VSS_OBJECT_TYPE,
                ppEnum: ?*?*IVssEnumObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssFileShareSnapshotProvider,
                QueriedObjectId: Guid,
                eQueriedObjectType: VSS_OBJECT_TYPE,
                eReturnedObjectsType: VSS_OBJECT_TYPE,
                ppEnum: ?*?*IVssEnumObject,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DeleteSnapshots: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssFileShareSnapshotProvider,
                SourceObjectId: Guid,
                eSourceObjectType: VSS_OBJECT_TYPE,
                bForceDelete: BOOL,
                plDeletedSnapshots: ?*i32,
                pNondeletedSnapshotID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssFileShareSnapshotProvider,
                SourceObjectId: Guid,
                eSourceObjectType: VSS_OBJECT_TYPE,
                bForceDelete: BOOL,
                plDeletedSnapshots: ?*i32,
                pNondeletedSnapshotID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        BeginPrepareSnapshot: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssFileShareSnapshotProvider,
                SnapshotSetId: Guid,
                SnapshotId: Guid,
                pwszSharePath: ?*u16,
                lNewContext: i32,
                ProviderId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssFileShareSnapshotProvider,
                SnapshotSetId: Guid,
                SnapshotId: Guid,
                pwszSharePath: ?*u16,
                lNewContext: i32,
                ProviderId: Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsPathSupported: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssFileShareSnapshotProvider,
                pwszSharePath: ?*u16,
                pbSupportedByThisProvider: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssFileShareSnapshotProvider,
                pwszSharePath: ?*u16,
                pbSupportedByThisProvider: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsPathSnapshotted: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssFileShareSnapshotProvider,
                pwszSharePath: ?*u16,
                pbSnapshotsPresent: ?*BOOL,
                plSnapshotCompatibility: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssFileShareSnapshotProvider,
                pwszSharePath: ?*u16,
                pbSnapshotsPresent: ?*BOOL,
                plSnapshotCompatibility: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetSnapshotProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IVssFileShareSnapshotProvider,
                SnapshotId: Guid,
                eSnapshotPropertyId: VSS_SNAPSHOT_PROPERTY_ID,
                vProperty: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IVssFileShareSnapshotProvider,
                SnapshotId: Guid,
                eSnapshotPropertyId: VSS_SNAPSHOT_PROPERTY_ID,
                vProperty: VARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssFileShareSnapshotProvider_SetContext(self: *const T, lContext: i32) HRESULT {
                return @as(*const IVssFileShareSnapshotProvider.VTable, @ptrCast(self.vtable)).SetContext(@as(*const IVssFileShareSnapshotProvider, @ptrCast(self)), lContext);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssFileShareSnapshotProvider_GetSnapshotProperties(self: *const T, SnapshotId: Guid, pProp: ?*VSS_SNAPSHOT_PROP) HRESULT {
                return @as(*const IVssFileShareSnapshotProvider.VTable, @ptrCast(self.vtable)).GetSnapshotProperties(@as(*const IVssFileShareSnapshotProvider, @ptrCast(self)), SnapshotId, pProp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssFileShareSnapshotProvider_Query(self: *const T, QueriedObjectId: Guid, eQueriedObjectType: VSS_OBJECT_TYPE, eReturnedObjectsType: VSS_OBJECT_TYPE, ppEnum: ?*?*IVssEnumObject) HRESULT {
                return @as(*const IVssFileShareSnapshotProvider.VTable, @ptrCast(self.vtable)).Query(@as(*const IVssFileShareSnapshotProvider, @ptrCast(self)), QueriedObjectId, eQueriedObjectType, eReturnedObjectsType, ppEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssFileShareSnapshotProvider_DeleteSnapshots(self: *const T, SourceObjectId: Guid, eSourceObjectType: VSS_OBJECT_TYPE, bForceDelete: BOOL, plDeletedSnapshots: ?*i32, pNondeletedSnapshotID: ?*Guid) HRESULT {
                return @as(*const IVssFileShareSnapshotProvider.VTable, @ptrCast(self.vtable)).DeleteSnapshots(@as(*const IVssFileShareSnapshotProvider, @ptrCast(self)), SourceObjectId, eSourceObjectType, bForceDelete, plDeletedSnapshots, pNondeletedSnapshotID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssFileShareSnapshotProvider_BeginPrepareSnapshot(self: *const T, SnapshotSetId: Guid, SnapshotId: Guid, pwszSharePath: ?*u16, lNewContext: i32, ProviderId: Guid) HRESULT {
                return @as(*const IVssFileShareSnapshotProvider.VTable, @ptrCast(self.vtable)).BeginPrepareSnapshot(@as(*const IVssFileShareSnapshotProvider, @ptrCast(self)), SnapshotSetId, SnapshotId, pwszSharePath, lNewContext, ProviderId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssFileShareSnapshotProvider_IsPathSupported(self: *const T, pwszSharePath: ?*u16, pbSupportedByThisProvider: ?*BOOL) HRESULT {
                return @as(*const IVssFileShareSnapshotProvider.VTable, @ptrCast(self.vtable)).IsPathSupported(@as(*const IVssFileShareSnapshotProvider, @ptrCast(self)), pwszSharePath, pbSupportedByThisProvider);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssFileShareSnapshotProvider_IsPathSnapshotted(self: *const T, pwszSharePath: ?*u16, pbSnapshotsPresent: ?*BOOL, plSnapshotCompatibility: ?*i32) HRESULT {
                return @as(*const IVssFileShareSnapshotProvider.VTable, @ptrCast(self.vtable)).IsPathSnapshotted(@as(*const IVssFileShareSnapshotProvider, @ptrCast(self)), pwszSharePath, pbSnapshotsPresent, plSnapshotCompatibility);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IVssFileShareSnapshotProvider_SetSnapshotProperty(self: *const T, SnapshotId: Guid, eSnapshotPropertyId: VSS_SNAPSHOT_PROPERTY_ID, vProperty: VARIANT) HRESULT {
                return @as(*const IVssFileShareSnapshotProvider.VTable, @ptrCast(self.vtable)).SetSnapshotProperty(@as(*const IVssFileShareSnapshotProvider, @ptrCast(self)), SnapshotId, eSnapshotPropertyId, vProperty);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

//--------------------------------------------------------------------------------
// Section: Functions (1)
//--------------------------------------------------------------------------------
// TODO: this type is limited to platform 'windows6.1'
pub extern "vssapi" fn CreateVssExpressWriterInternal(
    ppWriter: ?*?*IVssExpressWriter,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
    .ansi => struct {},
    .wide => struct {},
    .unspecified => if (@import("builtin").is_test) struct {} else struct {},
};
//--------------------------------------------------------------------------------
// Section: Imports (10)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const BSTR = @import("../foundation.zig").BSTR;
const FILETIME = @import("../foundation.zig").FILETIME;
const HRESULT = @import("../foundation.zig").HRESULT;
const IUnknown = @import("../system/com.zig").IUnknown;
const IXMLDOMDocument = @import("../data/xml/ms_xml.zig").IXMLDOMDocument;
const PWSTR = @import("../foundation.zig").PWSTR;
const VARIANT = @import("../system/com.zig").VARIANT;
const VDS_LUN_INFORMATION = @import("../storage/virtual_disk_service.zig").VDS_LUN_INFORMATION;

test {
    @setEvalBranchQuota(comptime @import("std").meta.declarations(@This()).len * 3);

    // reference all the pub declarations
    if (!@import("builtin").is_test) return;
    inline for (comptime @import("std").meta.declarations(@This())) |decl| {
        if (decl.is_pub) {
            _ = @field(@This(), decl.name);
        }
    }
}
