//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (1)
//--------------------------------------------------------------------------------
pub const OID_OAssociatedIdentityProviderObject = Guid.initString("98c5a3dd-db68-4f1a-8d2b-9079cdfeaf61");

//--------------------------------------------------------------------------------
// Section: Types (20)
//--------------------------------------------------------------------------------
pub const IDENTITY_TYPE = enum(i32) {
    ALL = 0,
    ME_ONLY = 1,
};
pub const IDENTITIES_ALL = IDENTITY_TYPE.ALL;
pub const IDENTITIES_ME_ONLY = IDENTITY_TYPE.ME_ONLY;

pub const IdentityUpdateEvent = enum(u32) {
    ASSOCIATED = 1,
    DISASSOCIATED = 2,
    CREATED = 4,
    IMPORTED = 8,
    DELETED = 16,
    PROPCHANGED = 32,
    CONNECTED = 64,
    DISCONNECTED = 128,
    _,
    pub fn initFlags(o: struct {
        ASSOCIATED: u1 = 0,
        DISASSOCIATED: u1 = 0,
        CREATED: u1 = 0,
        IMPORTED: u1 = 0,
        DELETED: u1 = 0,
        PROPCHANGED: u1 = 0,
        CONNECTED: u1 = 0,
        DISCONNECTED: u1 = 0,
    }) IdentityUpdateEvent {
        return @as(IdentityUpdateEvent, @enumFromInt((if (o.ASSOCIATED == 1) @intFromEnum(IdentityUpdateEvent.ASSOCIATED) else 0) | (if (o.DISASSOCIATED == 1) @intFromEnum(IdentityUpdateEvent.DISASSOCIATED) else 0) | (if (o.CREATED == 1) @intFromEnum(IdentityUpdateEvent.CREATED) else 0) | (if (o.IMPORTED == 1) @intFromEnum(IdentityUpdateEvent.IMPORTED) else 0) | (if (o.DELETED == 1) @intFromEnum(IdentityUpdateEvent.DELETED) else 0) | (if (o.PROPCHANGED == 1) @intFromEnum(IdentityUpdateEvent.PROPCHANGED) else 0) | (if (o.CONNECTED == 1) @intFromEnum(IdentityUpdateEvent.CONNECTED) else 0) | (if (o.DISCONNECTED == 1) @intFromEnum(IdentityUpdateEvent.DISCONNECTED) else 0)));
    }
};
pub const IDENTITY_ASSOCIATED = IdentityUpdateEvent.ASSOCIATED;
pub const IDENTITY_DISASSOCIATED = IdentityUpdateEvent.DISASSOCIATED;
pub const IDENTITY_CREATED = IdentityUpdateEvent.CREATED;
pub const IDENTITY_IMPORTED = IdentityUpdateEvent.IMPORTED;
pub const IDENTITY_DELETED = IdentityUpdateEvent.DELETED;
pub const IDENTITY_PROPCHANGED = IdentityUpdateEvent.PROPCHANGED;
pub const IDENTITY_CONNECTED = IdentityUpdateEvent.CONNECTED;
pub const IDENTITY_DISCONNECTED = IdentityUpdateEvent.DISCONNECTED;

// TODO: this type is limited to platform 'windows6.1'
const IID_IIdentityAdvise_Value = Guid.initString("4e982fed-d14b-440c-b8d6-bb386453d386");
pub const IID_IIdentityAdvise = &IID_IIdentityAdvise_Value;
pub const IIdentityAdvise = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        IdentityUpdated: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityAdvise,
                dwIdentityUpdateEvents: IdentityUpdateEvent,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityAdvise,
                dwIdentityUpdateEvents: IdentityUpdateEvent,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityAdvise_IdentityUpdated(self: *const T, dwIdentityUpdateEvents: IdentityUpdateEvent, lpszUniqueID: ?[*:0]const u16) HRESULT {
                return @as(*const IIdentityAdvise.VTable, @ptrCast(self.vtable)).IdentityUpdated(@as(*const IIdentityAdvise, @ptrCast(self)), dwIdentityUpdateEvents, lpszUniqueID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_AsyncIIdentityAdvise_Value = Guid.initString("3ab4c8da-d038-4830-8dd9-3253c55a127f");
pub const IID_AsyncIIdentityAdvise = &IID_AsyncIIdentityAdvise_Value;
pub const AsyncIIdentityAdvise = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Begin_IdentityUpdated: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityAdvise,
                dwIdentityUpdateEvents: u32,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityAdvise,
                dwIdentityUpdateEvents: u32,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_IdentityUpdated: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityAdvise,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityAdvise,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityAdvise_Begin_IdentityUpdated(self: *const T, dwIdentityUpdateEvents: u32, lpszUniqueID: ?[*:0]const u16) HRESULT {
                return @as(*const AsyncIIdentityAdvise.VTable, @ptrCast(self.vtable)).Begin_IdentityUpdated(@as(*const AsyncIIdentityAdvise, @ptrCast(self)), dwIdentityUpdateEvents, lpszUniqueID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityAdvise_Finish_IdentityUpdated(self: *const T) HRESULT {
                return @as(*const AsyncIIdentityAdvise.VTable, @ptrCast(self.vtable)).Finish_IdentityUpdated(@as(*const AsyncIIdentityAdvise, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_IIdentityProvider_Value = Guid.initString("0d1b9e0c-e8ba-4f55-a81b-bce934b948f5");
pub const IID_IIdentityProvider = &IID_IIdentityProvider_Value;
pub const IIdentityProvider = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetIdentityEnum: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityProvider,
                eIdentityType: IDENTITY_TYPE,
                pFilterkey: ?*const PROPERTYKEY,
                pFilterPropVarValue: ?*const PROPVARIANT,
                ppIdentityEnum: ?*?*IEnumUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityProvider,
                eIdentityType: IDENTITY_TYPE,
                pFilterkey: ?*const PROPERTYKEY,
                pFilterPropVarValue: ?*const PROPVARIANT,
                ppIdentityEnum: ?*?*IEnumUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Create: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityProvider,
                lpszUserName: ?[*:0]const u16,
                ppPropertyStore: ?*?*IPropertyStore,
                pKeywordsToAdd: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityProvider,
                lpszUserName: ?[*:0]const u16,
                ppPropertyStore: ?*?*IPropertyStore,
                pKeywordsToAdd: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Import: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityProvider,
                pPropertyStore: ?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityProvider,
                pPropertyStore: ?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityProvider,
                lpszUniqueID: ?[*:0]const u16,
                pKeywordsToDelete: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityProvider,
                lpszUniqueID: ?[*:0]const u16,
                pKeywordsToDelete: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindByUniqueID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityProvider,
                lpszUniqueID: ?[*:0]const u16,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityProvider,
                lpszUniqueID: ?[*:0]const u16,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetProviderPropertyStore: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityProvider,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityProvider,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Advise: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityProvider,
                pIdentityAdvise: ?*IIdentityAdvise,
                dwIdentityUpdateEvents: IdentityUpdateEvent,
                pdwCookie: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityProvider,
                pIdentityAdvise: ?*IIdentityAdvise,
                dwIdentityUpdateEvents: IdentityUpdateEvent,
                pdwCookie: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        UnAdvise: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityProvider,
                dwCookie: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityProvider,
                dwCookie: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityProvider_GetIdentityEnum(self: *const T, eIdentityType: IDENTITY_TYPE, pFilterkey: ?*const PROPERTYKEY, pFilterPropVarValue: ?*const PROPVARIANT, ppIdentityEnum: ?*?*IEnumUnknown) HRESULT {
                return @as(*const IIdentityProvider.VTable, @ptrCast(self.vtable)).GetIdentityEnum(@as(*const IIdentityProvider, @ptrCast(self)), eIdentityType, pFilterkey, pFilterPropVarValue, ppIdentityEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityProvider_Create(self: *const T, lpszUserName: ?[*:0]const u16, ppPropertyStore: ?*?*IPropertyStore, pKeywordsToAdd: ?*const PROPVARIANT) HRESULT {
                return @as(*const IIdentityProvider.VTable, @ptrCast(self.vtable)).Create(@as(*const IIdentityProvider, @ptrCast(self)), lpszUserName, ppPropertyStore, pKeywordsToAdd);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityProvider_Import(self: *const T, pPropertyStore: ?*IPropertyStore) HRESULT {
                return @as(*const IIdentityProvider.VTable, @ptrCast(self.vtable)).Import(@as(*const IIdentityProvider, @ptrCast(self)), pPropertyStore);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityProvider_Delete(self: *const T, lpszUniqueID: ?[*:0]const u16, pKeywordsToDelete: ?*const PROPVARIANT) HRESULT {
                return @as(*const IIdentityProvider.VTable, @ptrCast(self.vtable)).Delete(@as(*const IIdentityProvider, @ptrCast(self)), lpszUniqueID, pKeywordsToDelete);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityProvider_FindByUniqueID(self: *const T, lpszUniqueID: ?[*:0]const u16, ppPropertyStore: ?*?*IPropertyStore) HRESULT {
                return @as(*const IIdentityProvider.VTable, @ptrCast(self.vtable)).FindByUniqueID(@as(*const IIdentityProvider, @ptrCast(self)), lpszUniqueID, ppPropertyStore);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityProvider_GetProviderPropertyStore(self: *const T, ppPropertyStore: ?*?*IPropertyStore) HRESULT {
                return @as(*const IIdentityProvider.VTable, @ptrCast(self.vtable)).GetProviderPropertyStore(@as(*const IIdentityProvider, @ptrCast(self)), ppPropertyStore);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityProvider_Advise(self: *const T, pIdentityAdvise: ?*IIdentityAdvise, dwIdentityUpdateEvents: IdentityUpdateEvent, pdwCookie: ?*u32) HRESULT {
                return @as(*const IIdentityProvider.VTable, @ptrCast(self.vtable)).Advise(@as(*const IIdentityProvider, @ptrCast(self)), pIdentityAdvise, dwIdentityUpdateEvents, pdwCookie);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityProvider_UnAdvise(self: *const T, dwCookie: u32) HRESULT {
                return @as(*const IIdentityProvider.VTable, @ptrCast(self.vtable)).UnAdvise(@as(*const IIdentityProvider, @ptrCast(self)), dwCookie);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_AsyncIIdentityProvider_Value = Guid.initString("c6fc9901-c433-4646-8f48-4e4687aae2a0");
pub const IID_AsyncIIdentityProvider = &IID_AsyncIIdentityProvider_Value;
pub const AsyncIIdentityProvider = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Begin_GetIdentityEnum: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
                eIdentityType: IDENTITY_TYPE,
                pFilterkey: ?*const PROPERTYKEY,
                pFilterPropVarValue: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
                eIdentityType: IDENTITY_TYPE,
                pFilterkey: ?*const PROPERTYKEY,
                pFilterPropVarValue: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_GetIdentityEnum: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
                ppIdentityEnum: ?*?*IEnumUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
                ppIdentityEnum: ?*?*IEnumUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_Create: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
                lpszUserName: ?[*:0]const u16,
                pKeywordsToAdd: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
                lpszUserName: ?[*:0]const u16,
                pKeywordsToAdd: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_Create: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_Import: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
                pPropertyStore: ?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
                pPropertyStore: ?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_Import: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
                lpszUniqueID: ?[*:0]const u16,
                pKeywordsToDelete: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
                lpszUniqueID: ?[*:0]const u16,
                pKeywordsToDelete: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_FindByUniqueID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_FindByUniqueID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_GetProviderPropertyStore: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_GetProviderPropertyStore: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_Advise: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
                pIdentityAdvise: ?*IIdentityAdvise,
                dwIdentityUpdateEvents: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
                pIdentityAdvise: ?*IIdentityAdvise,
                dwIdentityUpdateEvents: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_Advise: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
                pdwCookie: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
                pdwCookie: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_UnAdvise: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
                dwCookie: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
                dwCookie: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_UnAdvise: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Begin_GetIdentityEnum(self: *const T, eIdentityType: IDENTITY_TYPE, pFilterkey: ?*const PROPERTYKEY, pFilterPropVarValue: ?*const PROPVARIANT) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_GetIdentityEnum(@as(*const AsyncIIdentityProvider, @ptrCast(self)), eIdentityType, pFilterkey, pFilterPropVarValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Finish_GetIdentityEnum(self: *const T, ppIdentityEnum: ?*?*IEnumUnknown) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_GetIdentityEnum(@as(*const AsyncIIdentityProvider, @ptrCast(self)), ppIdentityEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Begin_Create(self: *const T, lpszUserName: ?[*:0]const u16, pKeywordsToAdd: ?*const PROPVARIANT) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_Create(@as(*const AsyncIIdentityProvider, @ptrCast(self)), lpszUserName, pKeywordsToAdd);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Finish_Create(self: *const T, ppPropertyStore: ?*?*IPropertyStore) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_Create(@as(*const AsyncIIdentityProvider, @ptrCast(self)), ppPropertyStore);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Begin_Import(self: *const T, pPropertyStore: ?*IPropertyStore) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_Import(@as(*const AsyncIIdentityProvider, @ptrCast(self)), pPropertyStore);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Finish_Import(self: *const T) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_Import(@as(*const AsyncIIdentityProvider, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Begin_Delete(self: *const T, lpszUniqueID: ?[*:0]const u16, pKeywordsToDelete: ?*const PROPVARIANT) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_Delete(@as(*const AsyncIIdentityProvider, @ptrCast(self)), lpszUniqueID, pKeywordsToDelete);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Finish_Delete(self: *const T) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_Delete(@as(*const AsyncIIdentityProvider, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Begin_FindByUniqueID(self: *const T, lpszUniqueID: ?[*:0]const u16) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_FindByUniqueID(@as(*const AsyncIIdentityProvider, @ptrCast(self)), lpszUniqueID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Finish_FindByUniqueID(self: *const T, ppPropertyStore: ?*?*IPropertyStore) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_FindByUniqueID(@as(*const AsyncIIdentityProvider, @ptrCast(self)), ppPropertyStore);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Begin_GetProviderPropertyStore(self: *const T) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_GetProviderPropertyStore(@as(*const AsyncIIdentityProvider, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Finish_GetProviderPropertyStore(self: *const T, ppPropertyStore: ?*?*IPropertyStore) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_GetProviderPropertyStore(@as(*const AsyncIIdentityProvider, @ptrCast(self)), ppPropertyStore);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Begin_Advise(self: *const T, pIdentityAdvise: ?*IIdentityAdvise, dwIdentityUpdateEvents: u32) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_Advise(@as(*const AsyncIIdentityProvider, @ptrCast(self)), pIdentityAdvise, dwIdentityUpdateEvents);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Finish_Advise(self: *const T, pdwCookie: ?*u32) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_Advise(@as(*const AsyncIIdentityProvider, @ptrCast(self)), pdwCookie);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Begin_UnAdvise(self: *const T, dwCookie: u32) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_UnAdvise(@as(*const AsyncIIdentityProvider, @ptrCast(self)), dwCookie);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityProvider_Finish_UnAdvise(self: *const T) HRESULT {
                return @as(*const AsyncIIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_UnAdvise(@as(*const AsyncIIdentityProvider, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_IAssociatedIdentityProvider_Value = Guid.initString("2af066b3-4cbb-4cba-a798-204b6af68cc0");
pub const IID_IAssociatedIdentityProvider = &IID_IAssociatedIdentityProvider_Value;
pub const IAssociatedIdentityProvider = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        AssociateIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IAssociatedIdentityProvider,
                hwndParent: ?HWND,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IAssociatedIdentityProvider,
                hwndParent: ?HWND,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DisassociateIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IAssociatedIdentityProvider,
                hwndParent: ?HWND,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IAssociatedIdentityProvider,
                hwndParent: ?HWND,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ChangeCredential: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IAssociatedIdentityProvider,
                hwndParent: ?HWND,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IAssociatedIdentityProvider,
                hwndParent: ?HWND,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IAssociatedIdentityProvider_AssociateIdentity(self: *const T, hwndParent: ?HWND, ppPropertyStore: ?*?*IPropertyStore) HRESULT {
                return @as(*const IAssociatedIdentityProvider.VTable, @ptrCast(self.vtable)).AssociateIdentity(@as(*const IAssociatedIdentityProvider, @ptrCast(self)), hwndParent, ppPropertyStore);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IAssociatedIdentityProvider_DisassociateIdentity(self: *const T, hwndParent: ?HWND, lpszUniqueID: ?[*:0]const u16) HRESULT {
                return @as(*const IAssociatedIdentityProvider.VTable, @ptrCast(self.vtable)).DisassociateIdentity(@as(*const IAssociatedIdentityProvider, @ptrCast(self)), hwndParent, lpszUniqueID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IAssociatedIdentityProvider_ChangeCredential(self: *const T, hwndParent: ?HWND, lpszUniqueID: ?[*:0]const u16) HRESULT {
                return @as(*const IAssociatedIdentityProvider.VTable, @ptrCast(self.vtable)).ChangeCredential(@as(*const IAssociatedIdentityProvider, @ptrCast(self)), hwndParent, lpszUniqueID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_AsyncIAssociatedIdentityProvider_Value = Guid.initString("2834d6ed-297e-4e72-8a51-961e86f05152");
pub const IID_AsyncIAssociatedIdentityProvider = &IID_AsyncIAssociatedIdentityProvider_Value;
pub const AsyncIAssociatedIdentityProvider = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Begin_AssociateIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIAssociatedIdentityProvider,
                hwndParent: ?HWND,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIAssociatedIdentityProvider,
                hwndParent: ?HWND,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_AssociateIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIAssociatedIdentityProvider,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIAssociatedIdentityProvider,
                ppPropertyStore: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_DisassociateIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIAssociatedIdentityProvider,
                hwndParent: ?HWND,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIAssociatedIdentityProvider,
                hwndParent: ?HWND,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_DisassociateIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIAssociatedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIAssociatedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_ChangeCredential: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIAssociatedIdentityProvider,
                hwndParent: ?HWND,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIAssociatedIdentityProvider,
                hwndParent: ?HWND,
                lpszUniqueID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_ChangeCredential: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIAssociatedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIAssociatedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIAssociatedIdentityProvider_Begin_AssociateIdentity(self: *const T, hwndParent: ?HWND) HRESULT {
                return @as(*const AsyncIAssociatedIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_AssociateIdentity(@as(*const AsyncIAssociatedIdentityProvider, @ptrCast(self)), hwndParent);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIAssociatedIdentityProvider_Finish_AssociateIdentity(self: *const T, ppPropertyStore: ?*?*IPropertyStore) HRESULT {
                return @as(*const AsyncIAssociatedIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_AssociateIdentity(@as(*const AsyncIAssociatedIdentityProvider, @ptrCast(self)), ppPropertyStore);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIAssociatedIdentityProvider_Begin_DisassociateIdentity(self: *const T, hwndParent: ?HWND, lpszUniqueID: ?[*:0]const u16) HRESULT {
                return @as(*const AsyncIAssociatedIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_DisassociateIdentity(@as(*const AsyncIAssociatedIdentityProvider, @ptrCast(self)), hwndParent, lpszUniqueID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIAssociatedIdentityProvider_Finish_DisassociateIdentity(self: *const T) HRESULT {
                return @as(*const AsyncIAssociatedIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_DisassociateIdentity(@as(*const AsyncIAssociatedIdentityProvider, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIAssociatedIdentityProvider_Begin_ChangeCredential(self: *const T, hwndParent: ?HWND, lpszUniqueID: ?[*:0]const u16) HRESULT {
                return @as(*const AsyncIAssociatedIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_ChangeCredential(@as(*const AsyncIAssociatedIdentityProvider, @ptrCast(self)), hwndParent, lpszUniqueID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIAssociatedIdentityProvider_Finish_ChangeCredential(self: *const T) HRESULT {
                return @as(*const AsyncIAssociatedIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_ChangeCredential(@as(*const AsyncIAssociatedIdentityProvider, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const IDENTITY_URL = enum(i32) {
    CREATE_ACCOUNT_WIZARD = 0,
    SIGN_IN_WIZARD = 1,
    CHANGE_PASSWORD_WIZARD = 2,
    IFEXISTS_WIZARD = 3,
    ACCOUNT_SETTINGS = 4,
    RESTORE_WIZARD = 5,
    CONNECT_WIZARD = 6,
};
pub const IDENTITY_URL_CREATE_ACCOUNT_WIZARD = IDENTITY_URL.CREATE_ACCOUNT_WIZARD;
pub const IDENTITY_URL_SIGN_IN_WIZARD = IDENTITY_URL.SIGN_IN_WIZARD;
pub const IDENTITY_URL_CHANGE_PASSWORD_WIZARD = IDENTITY_URL.CHANGE_PASSWORD_WIZARD;
pub const IDENTITY_URL_IFEXISTS_WIZARD = IDENTITY_URL.IFEXISTS_WIZARD;
pub const IDENTITY_URL_ACCOUNT_SETTINGS = IDENTITY_URL.ACCOUNT_SETTINGS;
pub const IDENTITY_URL_RESTORE_WIZARD = IDENTITY_URL.RESTORE_WIZARD;
pub const IDENTITY_URL_CONNECT_WIZARD = IDENTITY_URL.CONNECT_WIZARD;

pub const ACCOUNT_STATE = enum(i32) {
    NOT_CONNECTED = 0,
    CONNECTING = 1,
    CONNECT_COMPLETED = 2,
};
pub const NOT_CONNECTED = ACCOUNT_STATE.NOT_CONNECTED;
pub const CONNECTING = ACCOUNT_STATE.CONNECTING;
pub const CONNECT_COMPLETED = ACCOUNT_STATE.CONNECT_COMPLETED;

// TODO: this type is limited to platform 'windows8.0'
const IID_IConnectedIdentityProvider_Value = Guid.initString("b7417b54-e08c-429b-96c8-678d1369ecb1");
pub const IID_IConnectedIdentityProvider = &IID_IConnectedIdentityProvider_Value;
pub const IConnectedIdentityProvider = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        ConnectIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IConnectedIdentityProvider,
                AuthBuffer: [*:0]u8,
                AuthBufferSize: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IConnectedIdentityProvider,
                AuthBuffer: [*:0]u8,
                AuthBufferSize: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DisconnectIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IConnectedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IConnectedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsConnected: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IConnectedIdentityProvider,
                Connected: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IConnectedIdentityProvider,
                Connected: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetUrl: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IConnectedIdentityProvider,
                Identifier: IDENTITY_URL,
                Context: ?*IBindCtx,
                PostData: ?*VARIANT,
                Url: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IConnectedIdentityProvider,
                Identifier: IDENTITY_URL,
                Context: ?*IBindCtx,
                PostData: ?*VARIANT,
                Url: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAccountState: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IConnectedIdentityProvider,
                pState: ?*ACCOUNT_STATE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IConnectedIdentityProvider,
                pState: ?*ACCOUNT_STATE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IConnectedIdentityProvider_ConnectIdentity(self: *const T, AuthBuffer: [*:0]u8, AuthBufferSize: u32) HRESULT {
                return @as(*const IConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).ConnectIdentity(@as(*const IConnectedIdentityProvider, @ptrCast(self)), AuthBuffer, AuthBufferSize);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IConnectedIdentityProvider_DisconnectIdentity(self: *const T) HRESULT {
                return @as(*const IConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).DisconnectIdentity(@as(*const IConnectedIdentityProvider, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IConnectedIdentityProvider_IsConnected(self: *const T, Connected: ?*BOOL) HRESULT {
                return @as(*const IConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).IsConnected(@as(*const IConnectedIdentityProvider, @ptrCast(self)), Connected);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IConnectedIdentityProvider_GetUrl(self: *const T, Identifier: IDENTITY_URL, Context: ?*IBindCtx, PostData: ?*VARIANT, Url: ?*?PWSTR) HRESULT {
                return @as(*const IConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).GetUrl(@as(*const IConnectedIdentityProvider, @ptrCast(self)), Identifier, Context, PostData, Url);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IConnectedIdentityProvider_GetAccountState(self: *const T, pState: ?*ACCOUNT_STATE) HRESULT {
                return @as(*const IConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).GetAccountState(@as(*const IConnectedIdentityProvider, @ptrCast(self)), pState);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_AsyncIConnectedIdentityProvider_Value = Guid.initString("9ce55141-bce9-4e15-824d-43d79f512f93");
pub const IID_AsyncIConnectedIdentityProvider = &IID_AsyncIConnectedIdentityProvider_Value;
pub const AsyncIConnectedIdentityProvider = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Begin_ConnectIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIConnectedIdentityProvider,
                AuthBuffer: [*:0]u8,
                AuthBufferSize: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIConnectedIdentityProvider,
                AuthBuffer: [*:0]u8,
                AuthBufferSize: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_ConnectIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIConnectedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIConnectedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_DisconnectIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIConnectedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIConnectedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_DisconnectIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIConnectedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIConnectedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_IsConnected: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIConnectedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIConnectedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_IsConnected: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIConnectedIdentityProvider,
                Connected: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIConnectedIdentityProvider,
                Connected: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_GetUrl: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIConnectedIdentityProvider,
                Identifier: IDENTITY_URL,
                Context: ?*IBindCtx,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIConnectedIdentityProvider,
                Identifier: IDENTITY_URL,
                Context: ?*IBindCtx,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_GetUrl: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIConnectedIdentityProvider,
                PostData: ?*VARIANT,
                Url: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIConnectedIdentityProvider,
                PostData: ?*VARIANT,
                Url: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_GetAccountState: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIConnectedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIConnectedIdentityProvider,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_GetAccountState: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIConnectedIdentityProvider,
                pState: ?*ACCOUNT_STATE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIConnectedIdentityProvider,
                pState: ?*ACCOUNT_STATE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIConnectedIdentityProvider_Begin_ConnectIdentity(self: *const T, AuthBuffer: [*:0]u8, AuthBufferSize: u32) HRESULT {
                return @as(*const AsyncIConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_ConnectIdentity(@as(*const AsyncIConnectedIdentityProvider, @ptrCast(self)), AuthBuffer, AuthBufferSize);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIConnectedIdentityProvider_Finish_ConnectIdentity(self: *const T) HRESULT {
                return @as(*const AsyncIConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_ConnectIdentity(@as(*const AsyncIConnectedIdentityProvider, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIConnectedIdentityProvider_Begin_DisconnectIdentity(self: *const T) HRESULT {
                return @as(*const AsyncIConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_DisconnectIdentity(@as(*const AsyncIConnectedIdentityProvider, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIConnectedIdentityProvider_Finish_DisconnectIdentity(self: *const T) HRESULT {
                return @as(*const AsyncIConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_DisconnectIdentity(@as(*const AsyncIConnectedIdentityProvider, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIConnectedIdentityProvider_Begin_IsConnected(self: *const T) HRESULT {
                return @as(*const AsyncIConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_IsConnected(@as(*const AsyncIConnectedIdentityProvider, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIConnectedIdentityProvider_Finish_IsConnected(self: *const T, Connected: ?*BOOL) HRESULT {
                return @as(*const AsyncIConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_IsConnected(@as(*const AsyncIConnectedIdentityProvider, @ptrCast(self)), Connected);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIConnectedIdentityProvider_Begin_GetUrl(self: *const T, Identifier: IDENTITY_URL, Context: ?*IBindCtx) HRESULT {
                return @as(*const AsyncIConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_GetUrl(@as(*const AsyncIConnectedIdentityProvider, @ptrCast(self)), Identifier, Context);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIConnectedIdentityProvider_Finish_GetUrl(self: *const T, PostData: ?*VARIANT, Url: ?*?PWSTR) HRESULT {
                return @as(*const AsyncIConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_GetUrl(@as(*const AsyncIConnectedIdentityProvider, @ptrCast(self)), PostData, Url);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIConnectedIdentityProvider_Begin_GetAccountState(self: *const T) HRESULT {
                return @as(*const AsyncIConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).Begin_GetAccountState(@as(*const AsyncIConnectedIdentityProvider, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIConnectedIdentityProvider_Finish_GetAccountState(self: *const T, pState: ?*ACCOUNT_STATE) HRESULT {
                return @as(*const AsyncIConnectedIdentityProvider.VTable, @ptrCast(self.vtable)).Finish_GetAccountState(@as(*const AsyncIConnectedIdentityProvider, @ptrCast(self)), pState);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IIdentityAuthentication_Value = Guid.initString("5e7ef254-979f-43b5-b74e-06e4eb7df0f9");
pub const IID_IIdentityAuthentication = &IID_IIdentityAuthentication_Value;
pub const IIdentityAuthentication = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetIdentityCredential: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityAuthentication,
                CredBuffer: ?[*:0]u8,
                CredBufferLength: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityAuthentication,
                CredBuffer: ?[*:0]u8,
                CredBufferLength: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ValidateIdentityCredential: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityAuthentication,
                CredBuffer: [*:0]u8,
                CredBufferLength: u32,
                ppIdentityProperties: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityAuthentication,
                CredBuffer: [*:0]u8,
                CredBufferLength: u32,
                ppIdentityProperties: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityAuthentication_SetIdentityCredential(self: *const T, CredBuffer: ?[*:0]u8, CredBufferLength: u32) HRESULT {
                return @as(*const IIdentityAuthentication.VTable, @ptrCast(self.vtable)).SetIdentityCredential(@as(*const IIdentityAuthentication, @ptrCast(self)), CredBuffer, CredBufferLength);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityAuthentication_ValidateIdentityCredential(self: *const T, CredBuffer: [*:0]u8, CredBufferLength: u32, ppIdentityProperties: ?*?*IPropertyStore) HRESULT {
                return @as(*const IIdentityAuthentication.VTable, @ptrCast(self.vtable)).ValidateIdentityCredential(@as(*const IIdentityAuthentication, @ptrCast(self)), CredBuffer, CredBufferLength, ppIdentityProperties);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_AsyncIIdentityAuthentication_Value = Guid.initString("f9a2f918-feca-4e9c-9633-61cbf13ed34d");
pub const IID_AsyncIIdentityAuthentication = &IID_AsyncIIdentityAuthentication_Value;
pub const AsyncIIdentityAuthentication = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Begin_SetIdentityCredential: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityAuthentication,
                CredBuffer: ?[*:0]u8,
                CredBufferLength: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityAuthentication,
                CredBuffer: ?[*:0]u8,
                CredBufferLength: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_SetIdentityCredential: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityAuthentication,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityAuthentication,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_ValidateIdentityCredential: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityAuthentication,
                CredBuffer: [*:0]u8,
                CredBufferLength: u32,
                ppIdentityProperties: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityAuthentication,
                CredBuffer: [*:0]u8,
                CredBufferLength: u32,
                ppIdentityProperties: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_ValidateIdentityCredential: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityAuthentication,
                ppIdentityProperties: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityAuthentication,
                ppIdentityProperties: ?*?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityAuthentication_Begin_SetIdentityCredential(self: *const T, CredBuffer: ?[*:0]u8, CredBufferLength: u32) HRESULT {
                return @as(*const AsyncIIdentityAuthentication.VTable, @ptrCast(self.vtable)).Begin_SetIdentityCredential(@as(*const AsyncIIdentityAuthentication, @ptrCast(self)), CredBuffer, CredBufferLength);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityAuthentication_Finish_SetIdentityCredential(self: *const T) HRESULT {
                return @as(*const AsyncIIdentityAuthentication.VTable, @ptrCast(self.vtable)).Finish_SetIdentityCredential(@as(*const AsyncIIdentityAuthentication, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityAuthentication_Begin_ValidateIdentityCredential(self: *const T, CredBuffer: [*:0]u8, CredBufferLength: u32, ppIdentityProperties: ?*?*IPropertyStore) HRESULT {
                return @as(*const AsyncIIdentityAuthentication.VTable, @ptrCast(self.vtable)).Begin_ValidateIdentityCredential(@as(*const AsyncIIdentityAuthentication, @ptrCast(self)), CredBuffer, CredBufferLength, ppIdentityProperties);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityAuthentication_Finish_ValidateIdentityCredential(self: *const T, ppIdentityProperties: ?*?*IPropertyStore) HRESULT {
                return @as(*const AsyncIIdentityAuthentication.VTable, @ptrCast(self.vtable)).Finish_ValidateIdentityCredential(@as(*const AsyncIIdentityAuthentication, @ptrCast(self)), ppIdentityProperties);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const CLSID_CoClassIdentityStore_Value = Guid.initString("30d49246-d217-465f-b00b-ac9ddd652eb7");
pub const CLSID_CoClassIdentityStore = &CLSID_CoClassIdentityStore_Value;

const CLSID_CIdentityProfileHandler_Value = Guid.initString("ecf5bf46-e3b6-449a-b56b-43f58f867814");
pub const CLSID_CIdentityProfileHandler = &CLSID_CIdentityProfileHandler_Value;

// TODO: this type is limited to platform 'windows6.1'
const IID_IIdentityStore_Value = Guid.initString("df586fa5-6f35-44f1-b209-b38e169772eb");
pub const IID_IIdentityStore = &IID_IIdentityStore_Value;
pub const IIdentityStore = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityStore,
                pdwProviders: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityStore,
                pdwProviders: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityStore,
                dwProvider: u32,
                pProvGuid: ?*Guid,
                ppIdentityProvider: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityStore,
                dwProvider: u32,
                pProvGuid: ?*Guid,
                ppIdentityProvider: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AddToCache: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityStore,
                lpszUniqueID: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityStore,
                lpszUniqueID: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ConvertToSid: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityStore,
                lpszUniqueID: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
                cbSid: u16,
                pSid: ?[*:0]u8,
                pcbRequiredSid: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityStore,
                lpszUniqueID: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
                cbSid: u16,
                pSid: ?[*:0]u8,
                pcbRequiredSid: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        EnumerateIdentities: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityStore,
                eIdentityType: IDENTITY_TYPE,
                pFilterkey: ?*const PROPERTYKEY,
                pFilterPropVarValue: ?*const PROPVARIANT,
                ppIdentityEnum: ?*?*IEnumUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityStore,
                eIdentityType: IDENTITY_TYPE,
                pFilterkey: ?*const PROPERTYKEY,
                pFilterPropVarValue: ?*const PROPVARIANT,
                ppIdentityEnum: ?*?*IEnumUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityStore_GetCount(self: *const T, pdwProviders: ?*u32) HRESULT {
                return @as(*const IIdentityStore.VTable, @ptrCast(self.vtable)).GetCount(@as(*const IIdentityStore, @ptrCast(self)), pdwProviders);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityStore_GetAt(self: *const T, dwProvider: u32, pProvGuid: ?*Guid, ppIdentityProvider: ?*?*IUnknown) HRESULT {
                return @as(*const IIdentityStore.VTable, @ptrCast(self.vtable)).GetAt(@as(*const IIdentityStore, @ptrCast(self)), dwProvider, pProvGuid, ppIdentityProvider);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityStore_AddToCache(self: *const T, lpszUniqueID: ?[*:0]const u16, ProviderGUID: ?*const Guid) HRESULT {
                return @as(*const IIdentityStore.VTable, @ptrCast(self.vtable)).AddToCache(@as(*const IIdentityStore, @ptrCast(self)), lpszUniqueID, ProviderGUID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityStore_ConvertToSid(self: *const T, lpszUniqueID: ?[*:0]const u16, ProviderGUID: ?*const Guid, cbSid: u16, pSid: ?[*:0]u8, pcbRequiredSid: ?*u16) HRESULT {
                return @as(*const IIdentityStore.VTable, @ptrCast(self.vtable)).ConvertToSid(@as(*const IIdentityStore, @ptrCast(self)), lpszUniqueID, ProviderGUID, cbSid, pSid, pcbRequiredSid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityStore_EnumerateIdentities(self: *const T, eIdentityType: IDENTITY_TYPE, pFilterkey: ?*const PROPERTYKEY, pFilterPropVarValue: ?*const PROPVARIANT, ppIdentityEnum: ?*?*IEnumUnknown) HRESULT {
                return @as(*const IIdentityStore.VTable, @ptrCast(self.vtable)).EnumerateIdentities(@as(*const IIdentityStore, @ptrCast(self)), eIdentityType, pFilterkey, pFilterPropVarValue, ppIdentityEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityStore_Reset(self: *const T) HRESULT {
                return @as(*const IIdentityStore.VTable, @ptrCast(self.vtable)).Reset(@as(*const IIdentityStore, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_AsyncIIdentityStore_Value = Guid.initString("eefa1616-48de-4872-aa64-6e6206535a51");
pub const IID_AsyncIIdentityStore = &IID_AsyncIIdentityStore_Value;
pub const AsyncIIdentityStore = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Begin_GetCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_GetCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStore,
                pdwProviders: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStore,
                pdwProviders: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_GetAt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStore,
                dwProvider: u32,
                pProvGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStore,
                dwProvider: u32,
                pProvGuid: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_GetAt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStore,
                pProvGuid: ?*Guid,
                ppIdentityProvider: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStore,
                pProvGuid: ?*Guid,
                ppIdentityProvider: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_AddToCache: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStore,
                lpszUniqueID: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStore,
                lpszUniqueID: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_AddToCache: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_ConvertToSid: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStore,
                lpszUniqueID: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
                cbSid: u16,
                pSid: ?*u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStore,
                lpszUniqueID: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
                cbSid: u16,
                pSid: ?*u8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_ConvertToSid: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStore,
                pSid: ?*u8,
                pcbRequiredSid: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStore,
                pSid: ?*u8,
                pcbRequiredSid: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_EnumerateIdentities: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStore,
                eIdentityType: IDENTITY_TYPE,
                pFilterkey: ?*const PROPERTYKEY,
                pFilterPropVarValue: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStore,
                eIdentityType: IDENTITY_TYPE,
                pFilterkey: ?*const PROPERTYKEY,
                pFilterPropVarValue: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_EnumerateIdentities: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStore,
                ppIdentityEnum: ?*?*IEnumUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStore,
                ppIdentityEnum: ?*?*IEnumUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStore_Begin_GetCount(self: *const T) HRESULT {
                return @as(*const AsyncIIdentityStore.VTable, @ptrCast(self.vtable)).Begin_GetCount(@as(*const AsyncIIdentityStore, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStore_Finish_GetCount(self: *const T, pdwProviders: ?*u32) HRESULT {
                return @as(*const AsyncIIdentityStore.VTable, @ptrCast(self.vtable)).Finish_GetCount(@as(*const AsyncIIdentityStore, @ptrCast(self)), pdwProviders);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStore_Begin_GetAt(self: *const T, dwProvider: u32, pProvGuid: ?*Guid) HRESULT {
                return @as(*const AsyncIIdentityStore.VTable, @ptrCast(self.vtable)).Begin_GetAt(@as(*const AsyncIIdentityStore, @ptrCast(self)), dwProvider, pProvGuid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStore_Finish_GetAt(self: *const T, pProvGuid: ?*Guid, ppIdentityProvider: ?*?*IUnknown) HRESULT {
                return @as(*const AsyncIIdentityStore.VTable, @ptrCast(self.vtable)).Finish_GetAt(@as(*const AsyncIIdentityStore, @ptrCast(self)), pProvGuid, ppIdentityProvider);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStore_Begin_AddToCache(self: *const T, lpszUniqueID: ?[*:0]const u16, ProviderGUID: ?*const Guid) HRESULT {
                return @as(*const AsyncIIdentityStore.VTable, @ptrCast(self.vtable)).Begin_AddToCache(@as(*const AsyncIIdentityStore, @ptrCast(self)), lpszUniqueID, ProviderGUID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStore_Finish_AddToCache(self: *const T) HRESULT {
                return @as(*const AsyncIIdentityStore.VTable, @ptrCast(self.vtable)).Finish_AddToCache(@as(*const AsyncIIdentityStore, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStore_Begin_ConvertToSid(self: *const T, lpszUniqueID: ?[*:0]const u16, ProviderGUID: ?*const Guid, cbSid: u16, pSid: ?*u8) HRESULT {
                return @as(*const AsyncIIdentityStore.VTable, @ptrCast(self.vtable)).Begin_ConvertToSid(@as(*const AsyncIIdentityStore, @ptrCast(self)), lpszUniqueID, ProviderGUID, cbSid, pSid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStore_Finish_ConvertToSid(self: *const T, pSid: ?*u8, pcbRequiredSid: ?*u16) HRESULT {
                return @as(*const AsyncIIdentityStore.VTable, @ptrCast(self.vtable)).Finish_ConvertToSid(@as(*const AsyncIIdentityStore, @ptrCast(self)), pSid, pcbRequiredSid);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStore_Begin_EnumerateIdentities(self: *const T, eIdentityType: IDENTITY_TYPE, pFilterkey: ?*const PROPERTYKEY, pFilterPropVarValue: ?*const PROPVARIANT) HRESULT {
                return @as(*const AsyncIIdentityStore.VTable, @ptrCast(self.vtable)).Begin_EnumerateIdentities(@as(*const AsyncIIdentityStore, @ptrCast(self)), eIdentityType, pFilterkey, pFilterPropVarValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStore_Finish_EnumerateIdentities(self: *const T, ppIdentityEnum: ?*?*IEnumUnknown) HRESULT {
                return @as(*const AsyncIIdentityStore.VTable, @ptrCast(self.vtable)).Finish_EnumerateIdentities(@as(*const AsyncIIdentityStore, @ptrCast(self)), ppIdentityEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStore_Begin_Reset(self: *const T) HRESULT {
                return @as(*const AsyncIIdentityStore.VTable, @ptrCast(self.vtable)).Begin_Reset(@as(*const AsyncIIdentityStore, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStore_Finish_Reset(self: *const T) HRESULT {
                return @as(*const AsyncIIdentityStore.VTable, @ptrCast(self.vtable)).Finish_Reset(@as(*const AsyncIIdentityStore, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IIdentityStoreEx_Value = Guid.initString("f9f9eb98-8f7f-4e38-9577-6980114ce32b");
pub const IID_IIdentityStoreEx = &IID_IIdentityStoreEx_Value;
pub const IIdentityStoreEx = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        CreateConnectedIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityStoreEx,
                LocalName: ?[*:0]const u16,
                ConnectedName: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityStoreEx,
                LocalName: ?[*:0]const u16,
                ConnectedName: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DeleteConnectedIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IIdentityStoreEx,
                ConnectedName: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IIdentityStoreEx,
                ConnectedName: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityStoreEx_CreateConnectedIdentity(self: *const T, LocalName: ?[*:0]const u16, ConnectedName: ?[*:0]const u16, ProviderGUID: ?*const Guid) HRESULT {
                return @as(*const IIdentityStoreEx.VTable, @ptrCast(self.vtable)).CreateConnectedIdentity(@as(*const IIdentityStoreEx, @ptrCast(self)), LocalName, ConnectedName, ProviderGUID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IIdentityStoreEx_DeleteConnectedIdentity(self: *const T, ConnectedName: ?[*:0]const u16, ProviderGUID: ?*const Guid) HRESULT {
                return @as(*const IIdentityStoreEx.VTable, @ptrCast(self.vtable)).DeleteConnectedIdentity(@as(*const IIdentityStoreEx, @ptrCast(self)), ConnectedName, ProviderGUID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_AsyncIIdentityStoreEx_Value = Guid.initString("fca3af9a-8a07-4eae-8632-ec3de658a36a");
pub const IID_AsyncIIdentityStoreEx = &IID_AsyncIIdentityStoreEx_Value;
pub const AsyncIIdentityStoreEx = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Begin_CreateConnectedIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStoreEx,
                LocalName: ?[*:0]const u16,
                ConnectedName: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStoreEx,
                LocalName: ?[*:0]const u16,
                ConnectedName: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_CreateConnectedIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStoreEx,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStoreEx,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Begin_DeleteConnectedIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStoreEx,
                ConnectedName: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStoreEx,
                ConnectedName: ?[*:0]const u16,
                ProviderGUID: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Finish_DeleteConnectedIdentity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const AsyncIIdentityStoreEx,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const AsyncIIdentityStoreEx,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStoreEx_Begin_CreateConnectedIdentity(self: *const T, LocalName: ?[*:0]const u16, ConnectedName: ?[*:0]const u16, ProviderGUID: ?*const Guid) HRESULT {
                return @as(*const AsyncIIdentityStoreEx.VTable, @ptrCast(self.vtable)).Begin_CreateConnectedIdentity(@as(*const AsyncIIdentityStoreEx, @ptrCast(self)), LocalName, ConnectedName, ProviderGUID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStoreEx_Finish_CreateConnectedIdentity(self: *const T) HRESULT {
                return @as(*const AsyncIIdentityStoreEx.VTable, @ptrCast(self.vtable)).Finish_CreateConnectedIdentity(@as(*const AsyncIIdentityStoreEx, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStoreEx_Begin_DeleteConnectedIdentity(self: *const T, ConnectedName: ?[*:0]const u16, ProviderGUID: ?*const Guid) HRESULT {
                return @as(*const AsyncIIdentityStoreEx.VTable, @ptrCast(self.vtable)).Begin_DeleteConnectedIdentity(@as(*const AsyncIIdentityStoreEx, @ptrCast(self)), ConnectedName, ProviderGUID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn AsyncIIdentityStoreEx_Finish_DeleteConnectedIdentity(self: *const T) HRESULT {
                return @as(*const AsyncIIdentityStoreEx.VTable, @ptrCast(self.vtable)).Finish_DeleteConnectedIdentity(@as(*const AsyncIIdentityStoreEx, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

//--------------------------------------------------------------------------------
// Section: Functions (0)
//--------------------------------------------------------------------------------

//--------------------------------------------------------------------------------
// 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 (12)
//--------------------------------------------------------------------------------
const Guid = @import("../../../zig.zig").Guid;
const BOOL = @import("../../../foundation.zig").BOOL;
const HRESULT = @import("../../../foundation.zig").HRESULT;
const HWND = @import("../../../foundation.zig").HWND;
const IBindCtx = @import("../../../system/com.zig").IBindCtx;
const IEnumUnknown = @import("../../../system/com.zig").IEnumUnknown;
const IPropertyStore = @import("../../../ui/shell/properties_system.zig").IPropertyStore;
const IUnknown = @import("../../../system/com.zig").IUnknown;
const PROPERTYKEY = @import("../../../ui/shell/properties_system.zig").PROPERTYKEY;
const PROPVARIANT = @import("../../../system/com/structured_storage.zig").PROPVARIANT;
const PWSTR = @import("../../../foundation.zig").PWSTR;
const VARIANT = @import("../../../system/com.zig").VARIANT;

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

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