midnadimple
/
zigwin32
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
zigwin32/win32/storage/vss.zig

4004 lines
221 KiB
Zig
Raw Permalink Blame History

//! 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 fn IVssEnumObject_Next(self: *const T, celt: u32, rgelt: [*]VSS_OBJECT_PROP, pceltFetched: ?*u32) callconv(.Inline) 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 fn IVssEnumObject_Skip(self: *const T, celt: u32) callconv(.Inline) 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 fn IVssEnumObject_Reset(self: *const T) callconv(.Inline) 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 fn IVssEnumObject_Clone(self: *const T, ppenum: ?*?*IVssEnumObject) callconv(.Inline) 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 fn IVssAsync_Cancel(self: *const T) callconv(.Inline) 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 fn IVssAsync_Wait(self: *const T, dwMilliseconds: u32) callconv(.Inline) 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 fn IVssAsync_QueryStatus(self: *const T, pHrResult: ?*HRESULT, pReserved: ?*i32) callconv(.Inline) 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 fn IVssWMFiledesc_GetPath(self: *const T, pbstrPath: ?*?BSTR) callconv(.Inline) 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 fn IVssWMFiledesc_GetFilespec(self: *const T, pbstrFilespec: ?*?BSTR) callconv(.Inline) 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 fn IVssWMFiledesc_GetRecursive(self: *const T, pbRecursive: ?*bool) callconv(.Inline) 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 fn IVssWMFiledesc_GetAlternateLocation(self: *const T, pbstrAlternateLocation: ?*?BSTR) callconv(.Inline) 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 fn IVssWMFiledesc_GetBackupTypeMask(self: *const T, pdwTypeMask: ?*u32) callconv(.Inline) 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 fn IVssWMDependency_GetWriterId(self: *const T, pWriterId: ?*Guid) callconv(.Inline) 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 fn IVssWMDependency_GetLogicalPath(self: *const T, pbstrLogicalPath: ?*?BSTR) callconv(.Inline) 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 fn IVssWMDependency_GetComponentName(self: *const T, pbstrComponentName: ?*?BSTR) callconv(.Inline) 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 fn IVssComponent_GetLogicalPath(self: *const T, pbstrPath: ?*?BSTR) callconv(.Inline) 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 fn IVssComponent_GetComponentType(self: *const T, pct: ?*VSS_COMPONENT_TYPE) callconv(.Inline) 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 fn IVssComponent_GetComponentName(self: *const T, pbstrName: ?*?BSTR) callconv(.Inline) 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 fn IVssComponent_GetBackupSucceeded(self: *const T, pbSucceeded: ?*bool) callconv(.Inline) 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 fn IVssComponent_GetAlternateLocationMappingCount(self: *const T, pcMappings: ?*u32) callconv(.Inline) 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 fn IVssComponent_GetAlternateLocationMapping(self: *const T, iMapping: u32, ppFiledesc: ?*?*IVssWMFiledesc) callconv(.Inline) 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 fn IVssComponent_SetBackupMetadata(self: *const T, wszData: ?[*:0]const u16) callconv(.Inline) 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 fn IVssComponent_GetBackupMetadata(self: *const T, pbstrData: ?*?BSTR) callconv(.Inline) 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 fn IVssComponent_AddPartialFile(self: *const T, wszPath: ?[*:0]const u16, wszFilename: ?[*:0]const u16, wszRanges: ?[*:0]const u16, wszMetadata: ?[*:0]const u16) callconv(.Inline) 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 fn IVssComponent_GetPartialFileCount(self: *const T, pcPartialFiles: ?*u32) callconv(.Inline) 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 fn IVssComponent_GetPartialFile(self: *const T, iPartialFile: u32, pbstrPath: ?*?BSTR, pbstrFilename: ?*?BSTR, pbstrRange: ?*?BSTR, pbstrMetadata: ?*?BSTR) callconv(.Inline) 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 fn IVssComponent_IsSelectedForRestore(self: *const T, pbSelectedForRestore: ?*bool) callconv(.Inline) 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 fn IVssComponent_GetAdditionalRestores(self: *const T, pbAdditionalRestores: ?*bool) callconv(.Inline) 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 fn IVssComponent_GetNewTargetCount(self: *const T, pcNewTarget: ?*u32) callconv(.Inline) 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 fn IVssComponent_GetNewTarget(self: *const T, iNewTarget: u32, ppFiledesc: ?*?*IVssWMFiledesc) callconv(.Inline) 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 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) callconv(.Inline) 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 fn IVssComponent_GetDirectedTargetCount(self: *const T, pcDirectedTarget: ?*u32) callconv(.Inline) 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 fn IVssComponent_GetDirectedTarget(self: *const T, iDirectedTarget: u32, pbstrSourcePath: ?*?BSTR, pbstrSourceFileName: ?*?BSTR, pbstrSourceRangeList: ?*?BSTR, pbstrDestinationPath: ?*?BSTR, pbstrDestinationFilename: ?*?BSTR, pbstrDestinationRangeList: ?*?BSTR) callconv(.Inline) 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 fn IVssComponent_SetRestoreMetadata(self: *const T, wszRestoreMetadata: ?[*:0]const u16) callconv(.Inline) 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 fn IVssComponent_GetRestoreMetadata(self: *const T, pbstrRestoreMetadata: ?*?BSTR) callconv(.Inline) 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 fn IVssComponent_SetRestoreTarget(self: *const T, target: VSS_RESTORE_TARGET) callconv(.Inline) 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 fn IVssComponent_GetRestoreTarget(self: *const T, pTarget: ?*VSS_RESTORE_TARGET) callconv(.Inline) 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 fn IVssComponent_SetPreRestoreFailureMsg(self: *const T, wszPreRestoreFailureMsg: ?[*:0]const u16) callconv(.Inline) 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 fn IVssComponent_GetPreRestoreFailureMsg(self: *const T, pbstrPreRestoreFailureMsg: ?*?BSTR) callconv(.Inline) 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 fn IVssComponent_SetPostRestoreFailureMsg(self: *const T, wszPostRestoreFailureMsg: ?[*:0]const u16) callconv(.Inline) 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 fn IVssComponent_GetPostRestoreFailureMsg(self: *const T, pbstrPostRestoreFailureMsg: ?*?BSTR) callconv(.Inline) 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 fn IVssComponent_SetBackupStamp(self: *const T, wszBackupStamp: ?[*:0]const u16) callconv(.Inline) 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 fn IVssComponent_GetBackupStamp(self: *const T, pbstrBackupStamp: ?*?BSTR) callconv(.Inline) 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 fn IVssComponent_GetPreviousBackupStamp(self: *const T, pbstrBackupStamp: ?*?BSTR) callconv(.Inline) 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 fn IVssComponent_GetBackupOptions(self: *const T, pbstrBackupOptions: ?*?BSTR) callconv(.Inline) 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 fn IVssComponent_GetRestoreOptions(self: *const T, pbstrRestoreOptions: ?*?BSTR) callconv(.Inline) 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 fn IVssComponent_GetRestoreSubcomponentCount(self: *const T, pcRestoreSubcomponent: ?*u32) callconv(.Inline) 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 fn IVssComponent_GetRestoreSubcomponent(self: *const T, iComponent: u32, pbstrLogicalPath: ?*?BSTR, pbstrComponentName: ?*?BSTR, pbRepair: ?*bool) callconv(.Inline) 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 fn IVssComponent_GetFileRestoreStatus(self: *const T, pStatus: ?*VSS_FILE_RESTORE_STATUS) callconv(.Inline) 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 fn IVssComponent_AddDifferencedFilesByLastModifyTime(self: *const T, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, bRecursive: BOOL, ftLastModifyTime: FILETIME) callconv(.Inline) 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 fn IVssComponent_AddDifferencedFilesByLastModifyLSN(self: *const T, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, bRecursive: BOOL, bstrLsnString: ?BSTR) callconv(.Inline) 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 fn IVssComponent_GetDifferencedFilesCount(self: *const T, pcDifferencedFiles: ?*u32) callconv(.Inline) 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 fn IVssComponent_GetDifferencedFile(self: *const T, iDifferencedFile: u32, pbstrPath: ?*?BSTR, pbstrFilespec: ?*?BSTR, pbRecursive: ?*BOOL, pbstrLsnString: ?*?BSTR, pftLastModifyTime: ?*FILETIME) callconv(.Inline) 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 fn IVssWriterComponents_GetComponentCount(self: *const T, pcComponents: ?*u32) callconv(.Inline) 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 fn IVssWriterComponents_GetWriterInfo(self: *const T, pidInstance: ?*Guid, pidWriter: ?*Guid) callconv(.Inline) 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 fn IVssWriterComponents_GetComponent(self: *const T, iComponent: u32, ppComponent: ?*?*IVssComponent) callconv(.Inline) 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 fn IVssComponentEx_SetPrepareForBackupFailureMsg(self: *const T, wszFailureMsg: ?[*:0]const u16) callconv(.Inline) 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 fn IVssComponentEx_SetPostSnapshotFailureMsg(self: *const T, wszFailureMsg: ?[*:0]const u16) callconv(.Inline) 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 fn IVssComponentEx_GetPrepareForBackupFailureMsg(self: *const T, pbstrFailureMsg: ?*?BSTR) callconv(.Inline) 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 fn IVssComponentEx_GetPostSnapshotFailureMsg(self: *const T, pbstrFailureMsg: ?*?BSTR) callconv(.Inline) 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 fn IVssComponentEx_GetAuthoritativeRestore(self: *const T, pbAuth: ?*bool) callconv(.Inline) 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 fn IVssComponentEx_GetRollForward(self: *const T, pRollType: ?*VSS_ROLLFORWARD_TYPE, pbstrPoint: ?*?BSTR) callconv(.Inline) 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 fn IVssComponentEx_GetRestoreName(self: *const T, pbstrName: ?*?BSTR) callconv(.Inline) 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 fn IVssComponentEx2_SetFailure(self: *const T, hr: HRESULT, hrApplication: HRESULT, wszApplicationMessage: ?[*:0]const u16, dwReserved: u32) callconv(.Inline) 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 fn IVssComponentEx2_GetFailure(self: *const T, phr: ?*HRESULT, phrApplication: ?*HRESULT, pbstrApplicationMessage: ?*?BSTR, pdwReserved: ?*u32) callconv(.Inline) 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 fn IVssCreateWriterMetadata_AddIncludeFiles(self: *const T, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, bRecursive: u8, wszAlternateLocation: ?[*:0]const u16) callconv(.Inline) 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 fn IVssCreateWriterMetadata_AddExcludeFiles(self: *const T, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, bRecursive: u8) callconv(.Inline) 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 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) callconv(.Inline) 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 fn IVssCreateWriterMetadata_AddDatabaseFiles(self: *const T, wszLogicalPath: ?[*:0]const u16, wszDatabaseName: ?[*:0]const u16, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, dwBackupTypeMask: u32) callconv(.Inline) 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 fn IVssCreateWriterMetadata_AddDatabaseLogFiles(self: *const T, wszLogicalPath: ?[*:0]const u16, wszDatabaseName: ?[*:0]const u16, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, dwBackupTypeMask: u32) callconv(.Inline) 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 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) callconv(.Inline) 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 fn IVssCreateWriterMetadata_SetRestoreMethod(self: *const T, method: VSS_RESTOREMETHOD_ENUM, wszService: ?[*:0]const u16, wszUserProcedure: ?[*:0]const u16, writerRestore: VSS_WRITERRESTORE_ENUM, bRebootRequired: u8) callconv(.Inline) 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 fn IVssCreateWriterMetadata_AddAlternateLocationMapping(self: *const T, wszSourcePath: ?[*:0]const u16, wszSourceFilespec: ?[*:0]const u16, bRecursive: u8, wszDestination: ?[*:0]const u16) callconv(.Inline) 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 fn IVssCreateWriterMetadata_AddComponentDependency(self: *const T, wszForLogicalPath: ?[*:0]const u16, wszForComponentName: ?[*:0]const u16, onWriterId: Guid, wszOnLogicalPath: ?[*:0]const u16, wszOnComponentName: ?[*:0]const u16) callconv(.Inline) 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 fn IVssCreateWriterMetadata_SetBackupSchema(self: *const T, dwSchemaMask: u32) callconv(.Inline) 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 fn IVssCreateWriterMetadata_GetDocument(self: *const T, pDoc: ?*?*IXMLDOMDocument) callconv(.Inline) 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 fn IVssCreateWriterMetadata_SaveAsXML(self: *const T, pbstrXML: ?*?BSTR) callconv(.Inline) 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 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) callconv(.Inline) 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 fn IVssWriterImpl_Subscribe(self: *const T, dwSubscribeTimeout: u32, dwEventFlags: u32) callconv(.Inline) 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 fn IVssWriterImpl_Unsubscribe(self: *const T) callconv(.Inline) 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 fn IVssWriterImpl_Uninitialize(self: *const T) callconv(.Inline) 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 fn IVssWriterImpl_GetCurrentVolumeArray(self: *const T) callconv(.Inline) ?*?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 fn IVssWriterImpl_GetCurrentVolumeCount(self: *const T) callconv(.Inline) 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 fn IVssWriterImpl_GetSnapshotDeviceName(self: *const T, wszOriginalVolume: ?[*:0]const u16, ppwszSnapshotDevice: ?*?PWSTR) callconv(.Inline) 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 fn IVssWriterImpl_GetCurrentSnapshotSetId(self: *const T) callconv(.Inline) 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 fn IVssWriterImpl_GetContext(self: *const T) callconv(.Inline) 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 fn IVssWriterImpl_GetCurrentLevel(self: *const T) callconv(.Inline) 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 fn IVssWriterImpl_IsPathAffected(self: *const T, wszPath: ?[*:0]const u16) callconv(.Inline) 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 fn IVssWriterImpl_IsBootableSystemStateBackedUp(self: *const T) callconv(.Inline) 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 fn IVssWriterImpl_AreComponentsSelected(self: *const T) callconv(.Inline) 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 fn IVssWriterImpl_GetBackupType(self: *const T) callconv(.Inline) 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 fn IVssWriterImpl_GetRestoreType(self: *const T) callconv(.Inline) 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 fn IVssWriterImpl_SetWriterFailure(self: *const T, hr: HRESULT) callconv(.Inline) 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 fn IVssWriterImpl_IsPartialFileSupportEnabled(self: *const T) callconv(.Inline) 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 fn IVssWriterImpl_InstallAlternateWriter(self: *const T, idWriter: Guid, clsid: Guid) callconv(.Inline) 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 fn IVssWriterImpl_GetIdentityInformation(self: *const T) callconv(.Inline) ?*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 fn IVssWriterImpl_SetWriterFailureEx(self: *const T, hr: HRESULT, hrApplication: HRESULT, wszApplicationMessage: ?[*:0]const u16) callconv(.Inline) 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 fn IVssWriterImpl_GetSessionId(self: *const T, idSession: ?*Guid) callconv(.Inline) 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 fn IVssWriterImpl_IsWriterShuttingDown(self: *const T) callconv(.Inline) 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 fn IVssCreateExpressWriterMetadata_AddExcludeFiles(self: *const T, wszPath: ?[*:0]const u16, wszFilespec: ?[*:0]const u16, bRecursive: u8) callconv(.Inline) 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 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) callconv(.Inline) 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 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) callconv(.Inline) 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 fn IVssCreateExpressWriterMetadata_SetRestoreMethod(self: *const T, method: VSS_RESTOREMETHOD_ENUM, wszService: ?[*:0]const u16, wszUserProcedure: ?[*:0]const u16, writerRestore: VSS_WRITERRESTORE_ENUM, bRebootRequired: u8) callconv(.Inline) 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 fn IVssCreateExpressWriterMetadata_AddComponentDependency(self: *const T, wszForLogicalPath: ?[*:0]const u16, wszForComponentName: ?[*:0]const u16, onWriterId: Guid, wszOnLogicalPath: ?[*:0]const u16, wszOnComponentName: ?[*:0]const u16) callconv(.Inline) 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 fn IVssCreateExpressWriterMetadata_SetBackupSchema(self: *const T, dwSchemaMask: u32) callconv(.Inline) 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 fn IVssCreateExpressWriterMetadata_SaveAsXML(self: *const T, pbstrXML: ?*?BSTR) callconv(.Inline) 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 fn IVssExpressWriter_CreateMetadata(self: *const T, writerId: Guid, writerName: ?[*:0]const u16, usageType: VSS_USAGE_TYPE, versionMajor: u32, versionMinor: u32, reserved: u32, ppMetadata: ?*?*IVssCreateExpressWriterMetadata) callconv(.Inline) 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 fn IVssExpressWriter_LoadMetadata(self: *const T, metadata: ?[*:0]const u16, reserved: u32) callconv(.Inline) 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 fn IVssExpressWriter_Register(self: *const T) callconv(.Inline) 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 fn IVssExpressWriter_Unregister(self: *const T, writerId: Guid) callconv(.Inline) 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 fn IVssSnapshotMgmt_GetProviderMgmtInterface(self: *const T, ProviderId: Guid, InterfaceId: ?*const Guid, ppItf: ?*?*IUnknown) callconv(.Inline) 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 fn IVssSnapshotMgmt_QueryVolumesSupportedForSnapshots(self: *const T, ProviderId: Guid, lContext: i32, ppEnum: ?*?*IVssEnumMgmtObject) callconv(.Inline) 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 fn IVssSnapshotMgmt_QuerySnapshotsByVolume(self: *const T, pwszVolumeName: ?*u16, ProviderId: Guid, ppEnum: ?*?*IVssEnumObject) callconv(.Inline) 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 fn IVssSnapshotMgmt2_GetMinDiffAreaSize(self: *const T, pllMinDiffAreaSize: ?*i64) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt_AddDiffArea(self: *const T, pwszVolumeName: ?*u16, pwszDiffAreaVolumeName: ?*u16, llMaximumDiffSpace: i64) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt_ChangeDiffAreaMaximumSize(self: *const T, pwszVolumeName: ?*u16, pwszDiffAreaVolumeName: ?*u16, llMaximumDiffSpace: i64) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt_QueryVolumesSupportedForDiffAreas(self: *const T, pwszOriginalVolumeName: ?*u16, ppEnum: ?*?*IVssEnumMgmtObject) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt_QueryDiffAreasForVolume(self: *const T, pwszVolumeName: ?*u16, ppEnum: ?*?*IVssEnumMgmtObject) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt_QueryDiffAreasOnVolume(self: *const T, pwszVolumeName: ?*u16, ppEnum: ?*?*IVssEnumMgmtObject) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt_QueryDiffAreasForSnapshot(self: *const T, SnapshotId: Guid, ppEnum: ?*?*IVssEnumMgmtObject) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt2_ChangeDiffAreaMaximumSizeEx(self: *const T, pwszVolumeName: ?*u16, pwszDiffAreaVolumeName: ?*u16, llMaximumDiffSpace: i64, bVolatile: BOOL) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt2_MigrateDiffAreas(self: *const T, pwszVolumeName: ?*u16, pwszDiffAreaVolumeName: ?*u16, pwszNewDiffAreaVolumeName: ?*u16) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt2_QueryMigrationStatus(self: *const T, pwszVolumeName: ?*u16, pwszDiffAreaVolumeName: ?*u16, ppAsync: ?*?*IVssAsync) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt2_SetSnapshotPriority(self: *const T, idSnapshot: Guid, priority: u8) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt3_SetVolumeProtectLevel(self: *const T, pwszVolumeName: ?*u16, protectionLevel: VSS_PROTECTION_LEVEL) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt3_GetVolumeProtectLevel(self: *const T, pwszVolumeName: ?*u16, protectionLevel: ?*VSS_VOLUME_PROTECTION_INFO) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt3_ClearVolumeProtectFault(self: *const T, pwszVolumeName: ?*u16) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt3_DeleteUnusedDiffAreas(self: *const T, pwszDiffAreaVolumeName: ?*u16) callconv(.Inline) 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 fn IVssDifferentialSoftwareSnapshotMgmt3_QuerySnapshotDeltaBitmap(self: *const T, idSnapshotOlder: Guid, idSnapshotYounger: Guid, pcBlockSizePerBit: ?*u32, pcBitmapLength: ?*u32, ppbBitmap: [*]?*u8) callconv(.Inline) 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 fn IVssEnumMgmtObject_Next(self: *const T, celt: u32, rgelt: [*]VSS_MGMT_OBJECT_PROP, pceltFetched: ?*u32) callconv(.Inline) 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 fn IVssEnumMgmtObject_Skip(self: *const T, celt: u32) callconv(.Inline) 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 fn IVssEnumMgmtObject_Reset(self: *const T) callconv(.Inline) 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 fn IVssEnumMgmtObject_Clone(self: *const T, ppenum: ?*?*IVssEnumMgmtObject) callconv(.Inline) 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 fn IVssAdmin_RegisterProvider(self: *const T, pProviderId: Guid, ClassId: Guid, pwszProviderName: ?*u16, eProviderType: VSS_PROVIDER_TYPE, pwszProviderVersion: ?*u16, ProviderVersionId: Guid) callconv(.Inline) 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 fn IVssAdmin_UnregisterProvider(self: *const T, ProviderId: Guid) callconv(.Inline) 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 fn IVssAdmin_QueryProviders(self: *const T, ppEnum: ?*?*IVssEnumObject) callconv(.Inline) 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 fn IVssAdmin_AbortAllSnapshotsInProgress(self: *const T) callconv(.Inline) 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 fn IVssAdminEx_GetProviderCapability(self: *const T, pProviderId: Guid, pllOriginalCapabilityMask: ?*u64) callconv(.Inline) 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 fn IVssAdminEx_GetProviderContext(self: *const T, ProviderId: Guid, plContext: ?*i32) callconv(.Inline) 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 fn IVssAdminEx_SetProviderContext(self: *const T, ProviderId: Guid, lContext: i32) callconv(.Inline) 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 fn IVssSoftwareSnapshotProvider_SetContext(self: *const T, lContext: i32) callconv(.Inline) 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 fn IVssSoftwareSnapshotProvider_GetSnapshotProperties(self: *const T, SnapshotId: Guid, pProp: ?*VSS_SNAPSHOT_PROP) callconv(.Inline) 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 fn IVssSoftwareSnapshotProvider_Query(self: *const T, QueriedObjectId: Guid, eQueriedObjectType: VSS_OBJECT_TYPE, eReturnedObjectsType: VSS_OBJECT_TYPE, ppEnum: ?*?*IVssEnumObject) callconv(.Inline) 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 fn IVssSoftwareSnapshotProvider_DeleteSnapshots(self: *const T, SourceObjectId: Guid, eSourceObjectType: VSS_OBJECT_TYPE, bForceDelete: BOOL, plDeletedSnapshots: ?*i32, pNondeletedSnapshotID: ?*Guid) callconv(.Inline) 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 fn IVssSoftwareSnapshotProvider_BeginPrepareSnapshot(self: *const T, SnapshotSetId: Guid, SnapshotId: Guid, pwszVolumeName: ?*u16, lNewContext: i32) callconv(.Inline) 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 fn IVssSoftwareSnapshotProvider_IsVolumeSupported(self: *const T, pwszVolumeName: ?*u16, pbSupportedByThisProvider: ?*BOOL) callconv(.Inline) 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 fn IVssSoftwareSnapshotProvider_IsVolumeSnapshotted(self: *const T, pwszVolumeName: ?*u16, pbSnapshotsPresent: ?*BOOL, plSnapshotCompatibility: ?*i32) callconv(.Inline) 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 fn IVssSoftwareSnapshotProvider_SetSnapshotProperty(self: *const T, SnapshotId: Guid, eSnapshotPropertyId: VSS_SNAPSHOT_PROPERTY_ID, vProperty: VARIANT) callconv(.Inline) 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 fn IVssSoftwareSnapshotProvider_RevertToSnapshot(self: *const T, SnapshotId: Guid) callconv(.Inline) 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 fn IVssSoftwareSnapshotProvider_QueryRevertStatus(self: *const T, pwszVolume: ?*u16, ppAsync: ?*?*IVssAsync) callconv(.Inline) 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 fn IVssProviderCreateSnapshotSet_EndPrepareSnapshots(self: *const T, SnapshotSetId: Guid) callconv(.Inline) 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 fn IVssProviderCreateSnapshotSet_PreCommitSnapshots(self: *const T, SnapshotSetId: Guid) callconv(.Inline) 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 fn IVssProviderCreateSnapshotSet_CommitSnapshots(self: *const T, SnapshotSetId: Guid) callconv(.Inline) 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 fn IVssProviderCreateSnapshotSet_PostCommitSnapshots(self: *const T, SnapshotSetId: Guid, lSnapshotsCount: i32) callconv(.Inline) 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 fn IVssProviderCreateSnapshotSet_PreFinalCommitSnapshots(self: *const T, SnapshotSetId: Guid) callconv(.Inline) 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 fn IVssProviderCreateSnapshotSet_PostFinalCommitSnapshots(self: *const T, SnapshotSetId: Guid) callconv(.Inline) 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 fn IVssProviderCreateSnapshotSet_AbortSnapshots(self: *const T, SnapshotSetId: Guid) callconv(.Inline) 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 fn IVssProviderNotifications_OnLoad(self: *const T, pCallback: ?*IUnknown) callconv(.Inline) 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 fn IVssProviderNotifications_OnUnload(self: *const T, bForceUnload: BOOL) callconv(.Inline) 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 fn IVssHardwareSnapshotProvider_AreLunsSupported(self: *const T, lLunCount: i32, lContext: i32, rgwszDevices: [*]?*u16, pLunInformation: [*]VDS_LUN_INFORMATION, pbIsSupported: ?*BOOL) callconv(.Inline) 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 fn IVssHardwareSnapshotProvider_FillInLunInfo(self: *const T, wszDeviceName: ?*u16, pLunInfo: ?*VDS_LUN_INFORMATION, pbIsSupported: ?*BOOL) callconv(.Inline) 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 fn IVssHardwareSnapshotProvider_BeginPrepareSnapshot(self: *const T, SnapshotSetId: Guid, SnapshotId: Guid, lContext: i32, lLunCount: i32, rgDeviceNames: [*]?*u16, rgLunInformation: [*]VDS_LUN_INFORMATION) callconv(.Inline) 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 fn IVssHardwareSnapshotProvider_GetTargetLuns(self: *const T, lLunCount: i32, rgDeviceNames: [*]?*u16, rgSourceLuns: [*]VDS_LUN_INFORMATION, rgDestinationLuns: [*]VDS_LUN_INFORMATION) callconv(.Inline) 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 fn IVssHardwareSnapshotProvider_LocateLuns(self: *const T, lLunCount: i32, rgSourceLuns: [*]VDS_LUN_INFORMATION) callconv(.Inline) 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 fn IVssHardwareSnapshotProvider_OnLunEmpty(self: *const T, wszDeviceName: ?*u16, pInformation: ?*VDS_LUN_INFORMATION) callconv(.Inline) 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 fn IVssHardwareSnapshotProviderEx_GetProviderCapabilities(self: *const T, pllOriginalCapabilityMask: ?*u64) callconv(.Inline) 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 fn IVssHardwareSnapshotProviderEx_OnLunStateChange(self: *const T, pSnapshotLuns: [*]VDS_LUN_INFORMATION, pOriginalLuns: [*]VDS_LUN_INFORMATION, dwCount: u32, dwFlags: u32) callconv(.Inline) 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 fn IVssHardwareSnapshotProviderEx_ResyncLuns(self: *const T, pSourceLuns: [*]VDS_LUN_INFORMATION, pTargetLuns: [*]VDS_LUN_INFORMATION, dwCount: u32, ppAsync: ?*?*IVssAsync) callconv(.Inline) 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 fn IVssHardwareSnapshotProviderEx_OnReuseLuns(self: *const T, pSnapshotLuns: [*]VDS_LUN_INFORMATION, pOriginalLuns: [*]VDS_LUN_INFORMATION, dwCount: u32) callconv(.Inline) 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 fn IVssFileShareSnapshotProvider_SetContext(self: *const T, lContext: i32) callconv(.Inline) 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 fn IVssFileShareSnapshotProvider_GetSnapshotProperties(self: *const T, SnapshotId: Guid, pProp: ?*VSS_SNAPSHOT_PROP) callconv(.Inline) 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 fn IVssFileShareSnapshotProvider_Query(self: *const T, QueriedObjectId: Guid, eQueriedObjectType: VSS_OBJECT_TYPE, eReturnedObjectsType: VSS_OBJECT_TYPE, ppEnum: ?*?*IVssEnumObject) callconv(.Inline) 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 fn IVssFileShareSnapshotProvider_DeleteSnapshots(self: *const T, SourceObjectId: Guid, eSourceObjectType: VSS_OBJECT_TYPE, bForceDelete: BOOL, plDeletedSnapshots: ?*i32, pNondeletedSnapshotID: ?*Guid) callconv(.Inline) 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 fn IVssFileShareSnapshotProvider_BeginPrepareSnapshot(self: *const T, SnapshotSetId: Guid, SnapshotId: Guid, pwszSharePath: ?*u16, lNewContext: i32, ProviderId: Guid) callconv(.Inline) 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 fn IVssFileShareSnapshotProvider_IsPathSupported(self: *const T, pwszSharePath: ?*u16, pbSupportedByThisProvider: ?*BOOL) callconv(.Inline) 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 fn IVssFileShareSnapshotProvider_IsPathSnapshotted(self: *const T, pwszSharePath: ?*u16, pbSnapshotsPresent: ?*BOOL, plSnapshotCompatibility: ?*i32) callconv(.Inline) 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 fn IVssFileShareSnapshotProvider_SetSnapshotProperty(self: *const T, SnapshotId: Guid, eSnapshotPropertyId: VSS_SNAPSHOT_PROPERTY_ID, vProperty: VARIANT) callconv(.Inline) 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| {
_ = @field(@This(), decl.name);
}
}
Reference in New Issue View Git Blame Copy Permalink