//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (7)
//--------------------------------------------------------------------------------
pub const CGD_DEFAULT = @as(u32, 0);
pub const CGD_UNKNOWN_PROPERTY = @as(u32, 0);
pub const CGD_STRING_PROPERTY = @as(u32, 1);
pub const CGD_DATE_PROPERTY = @as(u32, 2);
pub const CGD_BINARY_PROPERTY = @as(u32, 4);
pub const CGD_ARRAY_NODE = @as(u32, 8);
pub const CLSID_ContactAggregationManager = Guid.initString("96c8ad95-c199-44de-b34e-ac33c442df39");

//--------------------------------------------------------------------------------
// Section: Types (21)
//--------------------------------------------------------------------------------
const CLSID_Contact_Value = Guid.initString("61b68808-8eee-4fd1-acb8-3d804c8db056");
pub const CLSID_Contact = &CLSID_Contact_Value;

const CLSID_ContactManager_Value = Guid.initString("7165c8ab-af88-42bd-86fd-5310b4285a02");
pub const CLSID_ContactManager = &CLSID_ContactManager_Value;

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IContactManager_Value = Guid.initString("ad553d98-deb1-474a-8e17-fc0c2075b738");
pub const IID_IContactManager = &IID_IContactManager_Value;
pub const IContactManager = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Initialize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactManager,
                pszAppName: ?[*:0]const u16,
                pszAppVersion: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactManager,
                pszAppName: ?[*:0]const u16,
                pszAppVersion: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Load: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactManager,
                pszContactID: ?[*:0]const u16,
                ppContact: ?*?*IContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactManager,
                pszContactID: ?[*:0]const u16,
                ppContact: ?*?*IContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MergeContactIDs: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactManager,
                pszNewContactID: ?[*:0]const u16,
                pszOldContactID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactManager,
                pszNewContactID: ?[*:0]const u16,
                pszOldContactID: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMeContact: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactManager,
                ppMeContact: ?*?*IContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactManager,
                ppMeContact: ?*?*IContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetMeContact: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactManager,
                pMeContact: ?*IContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactManager,
                pMeContact: ?*IContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetContactCollection: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactManager,
                ppContactCollection: ?*?*IContactCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactManager,
                ppContactCollection: ?*?*IContactCollection,
            ) 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 IContactManager_Initialize(self: *const T, pszAppName: ?[*:0]const u16, pszAppVersion: ?[*:0]const u16) HRESULT {
                return @as(*const IContactManager.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IContactManager, @ptrCast(self)), pszAppName, pszAppVersion);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactManager_Load(self: *const T, pszContactID: ?[*:0]const u16, ppContact: ?*?*IContact) HRESULT {
                return @as(*const IContactManager.VTable, @ptrCast(self.vtable)).Load(@as(*const IContactManager, @ptrCast(self)), pszContactID, ppContact);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactManager_MergeContactIDs(self: *const T, pszNewContactID: ?[*:0]const u16, pszOldContactID: ?[*:0]const u16) HRESULT {
                return @as(*const IContactManager.VTable, @ptrCast(self.vtable)).MergeContactIDs(@as(*const IContactManager, @ptrCast(self)), pszNewContactID, pszOldContactID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactManager_GetMeContact(self: *const T, ppMeContact: ?*?*IContact) HRESULT {
                return @as(*const IContactManager.VTable, @ptrCast(self.vtable)).GetMeContact(@as(*const IContactManager, @ptrCast(self)), ppMeContact);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactManager_SetMeContact(self: *const T, pMeContact: ?*IContact) HRESULT {
                return @as(*const IContactManager.VTable, @ptrCast(self.vtable)).SetMeContact(@as(*const IContactManager, @ptrCast(self)), pMeContact);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactManager_GetContactCollection(self: *const T, ppContactCollection: ?*?*IContactCollection) HRESULT {
                return @as(*const IContactManager.VTable, @ptrCast(self.vtable)).GetContactCollection(@as(*const IContactManager, @ptrCast(self)), ppContactCollection);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IContactCollection_Value = Guid.initString("b6afa338-d779-11d9-8bde-f66bad1e3f3a");
pub const IID_IContactCollection = &IID_IContactCollection_Value;
pub const IContactCollection = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Next: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCurrent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactCollection,
                ppContact: ?*?*IContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactCollection,
                ppContact: ?*?*IContact,
            ) 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 IContactCollection_Reset(self: *const T) HRESULT {
                return @as(*const IContactCollection.VTable, @ptrCast(self.vtable)).Reset(@as(*const IContactCollection, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactCollection_Next(self: *const T) HRESULT {
                return @as(*const IContactCollection.VTable, @ptrCast(self.vtable)).Next(@as(*const IContactCollection, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactCollection_GetCurrent(self: *const T, ppContact: ?*?*IContact) HRESULT {
                return @as(*const IContactCollection.VTable, @ptrCast(self.vtable)).GetCurrent(@as(*const IContactCollection, @ptrCast(self)), ppContact);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IContactProperties_Value = Guid.initString("70dd27dd-5cbd-46e8-bef0-23b6b346288f");
pub const IID_IContactProperties = &IID_IContactProperties_Value;
pub const IContactProperties = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetString: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
                pszValue: [*:0]u16,
                cchValue: u32,
                pdwcchPropertyValueRequired: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
                pszValue: [*:0]u16,
                cchValue: u32,
                pdwcchPropertyValueRequired: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
                pftDateTime: ?*FILETIME,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
                pftDateTime: ?*FILETIME,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBinary: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
                pszContentType: [*:0]u16,
                cchContentType: u32,
                pdwcchContentTypeRequired: ?*u32,
                ppStream: ?*?*IStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
                pszContentType: [*:0]u16,
                cchContentType: u32,
                pdwcchContentTypeRequired: ?*u32,
                ppStream: ?*?*IStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetLabels: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactProperties,
                pszArrayElementName: ?[*:0]const u16,
                dwFlags: u32,
                pszLabels: [*:0]u16,
                cchLabels: u32,
                pdwcchLabelsRequired: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactProperties,
                pszArrayElementName: ?[*:0]const u16,
                dwFlags: u32,
                pszLabels: [*:0]u16,
                cchLabels: u32,
                pdwcchLabelsRequired: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetString: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
                pszValue: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
                pszValue: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetDate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
                ftDateTime: FILETIME,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
                ftDateTime: FILETIME,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetBinary: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
                pszContentType: ?[*:0]const u16,
                pStream: ?*IStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
                pszContentType: ?[*:0]const u16,
                pStream: ?*IStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetLabels: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactProperties,
                pszArrayElementName: ?[*:0]const u16,
                dwFlags: u32,
                dwLabelCount: u32,
                ppszLabels: [*]?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactProperties,
                pszArrayElementName: ?[*:0]const u16,
                dwFlags: u32,
                dwLabelCount: u32,
                ppszLabels: [*]?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateArrayNode: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactProperties,
                pszArrayName: ?[*:0]const u16,
                dwFlags: u32,
                fAppend: BOOL,
                pszNewArrayElementName: [*:0]u16,
                cchNewArrayElementName: u32,
                pdwcchNewArrayElementNameRequired: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactProperties,
                pszArrayName: ?[*:0]const u16,
                dwFlags: u32,
                fAppend: BOOL,
                pszNewArrayElementName: [*:0]u16,
                cchNewArrayElementName: u32,
                pdwcchNewArrayElementNameRequired: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DeleteProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactProperties,
                pszPropertyName: ?[*:0]const u16,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DeleteArrayNode: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactProperties,
                pszArrayElementName: ?[*:0]const u16,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactProperties,
                pszArrayElementName: ?[*:0]const u16,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DeleteLabels: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactProperties,
                pszArrayElementName: ?[*:0]const u16,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactProperties,
                pszArrayElementName: ?[*:0]const u16,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPropertyCollection: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactProperties,
                ppPropertyCollection: ?*?*IContactPropertyCollection,
                dwFlags: u32,
                pszMultiValueName: ?[*:0]const u16,
                dwLabelCount: u32,
                ppszLabels: [*]?PWSTR,
                fAnyLabelMatches: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactProperties,
                ppPropertyCollection: ?*?*IContactPropertyCollection,
                dwFlags: u32,
                pszMultiValueName: ?[*:0]const u16,
                dwLabelCount: u32,
                ppszLabels: [*]?PWSTR,
                fAnyLabelMatches: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactProperties_GetString(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32, pszValue: [*:0]u16, cchValue: u32, pdwcchPropertyValueRequired: ?*u32) HRESULT {
                return @as(*const IContactProperties.VTable, @ptrCast(self.vtable)).GetString(@as(*const IContactProperties, @ptrCast(self)), pszPropertyName, dwFlags, pszValue, cchValue, pdwcchPropertyValueRequired);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactProperties_GetDate(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32, pftDateTime: ?*FILETIME) HRESULT {
                return @as(*const IContactProperties.VTable, @ptrCast(self.vtable)).GetDate(@as(*const IContactProperties, @ptrCast(self)), pszPropertyName, dwFlags, pftDateTime);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactProperties_GetBinary(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32, pszContentType: [*:0]u16, cchContentType: u32, pdwcchContentTypeRequired: ?*u32, ppStream: ?*?*IStream) HRESULT {
                return @as(*const IContactProperties.VTable, @ptrCast(self.vtable)).GetBinary(@as(*const IContactProperties, @ptrCast(self)), pszPropertyName, dwFlags, pszContentType, cchContentType, pdwcchContentTypeRequired, ppStream);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactProperties_GetLabels(self: *const T, pszArrayElementName: ?[*:0]const u16, dwFlags: u32, pszLabels: [*:0]u16, cchLabels: u32, pdwcchLabelsRequired: ?*u32) HRESULT {
                return @as(*const IContactProperties.VTable, @ptrCast(self.vtable)).GetLabels(@as(*const IContactProperties, @ptrCast(self)), pszArrayElementName, dwFlags, pszLabels, cchLabels, pdwcchLabelsRequired);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactProperties_SetString(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32, pszValue: ?[*:0]const u16) HRESULT {
                return @as(*const IContactProperties.VTable, @ptrCast(self.vtable)).SetString(@as(*const IContactProperties, @ptrCast(self)), pszPropertyName, dwFlags, pszValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactProperties_SetDate(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32, ftDateTime: FILETIME) HRESULT {
                return @as(*const IContactProperties.VTable, @ptrCast(self.vtable)).SetDate(@as(*const IContactProperties, @ptrCast(self)), pszPropertyName, dwFlags, ftDateTime);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactProperties_SetBinary(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32, pszContentType: ?[*:0]const u16, pStream: ?*IStream) HRESULT {
                return @as(*const IContactProperties.VTable, @ptrCast(self.vtable)).SetBinary(@as(*const IContactProperties, @ptrCast(self)), pszPropertyName, dwFlags, pszContentType, pStream);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactProperties_SetLabels(self: *const T, pszArrayElementName: ?[*:0]const u16, dwFlags: u32, dwLabelCount: u32, ppszLabels: [*]?PWSTR) HRESULT {
                return @as(*const IContactProperties.VTable, @ptrCast(self.vtable)).SetLabels(@as(*const IContactProperties, @ptrCast(self)), pszArrayElementName, dwFlags, dwLabelCount, ppszLabels);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactProperties_CreateArrayNode(self: *const T, pszArrayName: ?[*:0]const u16, dwFlags: u32, fAppend: BOOL, pszNewArrayElementName: [*:0]u16, cchNewArrayElementName: u32, pdwcchNewArrayElementNameRequired: ?*u32) HRESULT {
                return @as(*const IContactProperties.VTable, @ptrCast(self.vtable)).CreateArrayNode(@as(*const IContactProperties, @ptrCast(self)), pszArrayName, dwFlags, fAppend, pszNewArrayElementName, cchNewArrayElementName, pdwcchNewArrayElementNameRequired);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactProperties_DeleteProperty(self: *const T, pszPropertyName: ?[*:0]const u16, dwFlags: u32) HRESULT {
                return @as(*const IContactProperties.VTable, @ptrCast(self.vtable)).DeleteProperty(@as(*const IContactProperties, @ptrCast(self)), pszPropertyName, dwFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactProperties_DeleteArrayNode(self: *const T, pszArrayElementName: ?[*:0]const u16, dwFlags: u32) HRESULT {
                return @as(*const IContactProperties.VTable, @ptrCast(self.vtable)).DeleteArrayNode(@as(*const IContactProperties, @ptrCast(self)), pszArrayElementName, dwFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactProperties_DeleteLabels(self: *const T, pszArrayElementName: ?[*:0]const u16, dwFlags: u32) HRESULT {
                return @as(*const IContactProperties.VTable, @ptrCast(self.vtable)).DeleteLabels(@as(*const IContactProperties, @ptrCast(self)), pszArrayElementName, dwFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactProperties_GetPropertyCollection(self: *const T, ppPropertyCollection: ?*?*IContactPropertyCollection, dwFlags: u32, pszMultiValueName: ?[*:0]const u16, dwLabelCount: u32, ppszLabels: [*]?PWSTR, fAnyLabelMatches: BOOL) HRESULT {
                return @as(*const IContactProperties.VTable, @ptrCast(self.vtable)).GetPropertyCollection(@as(*const IContactProperties, @ptrCast(self)), ppPropertyCollection, dwFlags, pszMultiValueName, dwLabelCount, ppszLabels, fAnyLabelMatches);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IContact_Value = Guid.initString("f941b671-bda7-4f77-884a-f46462f226a7");
pub const IID_IContact = &IID_IContact_Value;
pub const IContact = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetContactID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContact,
                pszContactID: [*:0]u16,
                cchContactID: u32,
                pdwcchContactIDRequired: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContact,
                pszContactID: [*:0]u16,
                cchContactID: u32,
                pdwcchContactIDRequired: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPath: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContact,
                pszPath: [*:0]u16,
                cchPath: u32,
                pdwcchPathRequired: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContact,
                pszPath: [*:0]u16,
                cchPath: u32,
                pdwcchPathRequired: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CommitChanges: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContact,
                dwCommitFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContact,
                dwCommitFlags: 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 IContact_GetContactID(self: *const T, pszContactID: [*:0]u16, cchContactID: u32, pdwcchContactIDRequired: ?*u32) HRESULT {
                return @as(*const IContact.VTable, @ptrCast(self.vtable)).GetContactID(@as(*const IContact, @ptrCast(self)), pszContactID, cchContactID, pdwcchContactIDRequired);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContact_GetPath(self: *const T, pszPath: [*:0]u16, cchPath: u32, pdwcchPathRequired: ?*u32) HRESULT {
                return @as(*const IContact.VTable, @ptrCast(self.vtable)).GetPath(@as(*const IContact, @ptrCast(self)), pszPath, cchPath, pdwcchPathRequired);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContact_CommitChanges(self: *const T, dwCommitFlags: u32) HRESULT {
                return @as(*const IContact.VTable, @ptrCast(self.vtable)).CommitChanges(@as(*const IContact, @ptrCast(self)), dwCommitFlags);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.0.6000'
const IID_IContactPropertyCollection_Value = Guid.initString("ffd3adf8-fa64-4328-b1b6-2e0db509cb3c");
pub const IID_IContactPropertyCollection = &IID_IContactPropertyCollection_Value;
pub const IContactPropertyCollection = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactPropertyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactPropertyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Next: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactPropertyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactPropertyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPropertyName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactPropertyCollection,
                pszPropertyName: [*:0]u16,
                cchPropertyName: u32,
                pdwcchPropertyNameRequired: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactPropertyCollection,
                pszPropertyName: [*:0]u16,
                cchPropertyName: u32,
                pdwcchPropertyNameRequired: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPropertyType: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactPropertyCollection,
                pdwType: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactPropertyCollection,
                pdwType: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPropertyVersion: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactPropertyCollection,
                pdwVersion: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactPropertyCollection,
                pdwVersion: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPropertyModificationDate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactPropertyCollection,
                pftModificationDate: ?*FILETIME,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactPropertyCollection,
                pftModificationDate: ?*FILETIME,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPropertyArrayElementID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactPropertyCollection,
                pszArrayElementID: [*:0]u16,
                cchArrayElementID: u32,
                pdwcchArrayElementIDRequired: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactPropertyCollection,
                pszArrayElementID: [*:0]u16,
                cchArrayElementID: u32,
                pdwcchArrayElementIDRequired: ?*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 IContactPropertyCollection_Reset(self: *const T) HRESULT {
                return @as(*const IContactPropertyCollection.VTable, @ptrCast(self.vtable)).Reset(@as(*const IContactPropertyCollection, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactPropertyCollection_Next(self: *const T) HRESULT {
                return @as(*const IContactPropertyCollection.VTable, @ptrCast(self.vtable)).Next(@as(*const IContactPropertyCollection, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactPropertyCollection_GetPropertyName(self: *const T, pszPropertyName: [*:0]u16, cchPropertyName: u32, pdwcchPropertyNameRequired: ?*u32) HRESULT {
                return @as(*const IContactPropertyCollection.VTable, @ptrCast(self.vtable)).GetPropertyName(@as(*const IContactPropertyCollection, @ptrCast(self)), pszPropertyName, cchPropertyName, pdwcchPropertyNameRequired);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactPropertyCollection_GetPropertyType(self: *const T, pdwType: ?*u32) HRESULT {
                return @as(*const IContactPropertyCollection.VTable, @ptrCast(self.vtable)).GetPropertyType(@as(*const IContactPropertyCollection, @ptrCast(self)), pdwType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactPropertyCollection_GetPropertyVersion(self: *const T, pdwVersion: ?*u32) HRESULT {
                return @as(*const IContactPropertyCollection.VTable, @ptrCast(self.vtable)).GetPropertyVersion(@as(*const IContactPropertyCollection, @ptrCast(self)), pdwVersion);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactPropertyCollection_GetPropertyModificationDate(self: *const T, pftModificationDate: ?*FILETIME) HRESULT {
                return @as(*const IContactPropertyCollection.VTable, @ptrCast(self.vtable)).GetPropertyModificationDate(@as(*const IContactPropertyCollection, @ptrCast(self)), pftModificationDate);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactPropertyCollection_GetPropertyArrayElementID(self: *const T, pszArrayElementID: [*:0]u16, cchArrayElementID: u32, pdwcchArrayElementIDRequired: ?*u32) HRESULT {
                return @as(*const IContactPropertyCollection.VTable, @ptrCast(self.vtable)).GetPropertyArrayElementID(@as(*const IContactPropertyCollection, @ptrCast(self)), pszArrayElementID, cchArrayElementID, pdwcchArrayElementIDRequired);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const CONTACT_AGGREGATION_CREATE_OR_OPEN_OPTIONS = enum(i32) {
    LOCAL = 0,
    EXTERNAL = 1,
};
pub const CA_CREATE_LOCAL = CONTACT_AGGREGATION_CREATE_OR_OPEN_OPTIONS.LOCAL;
pub const CA_CREATE_EXTERNAL = CONTACT_AGGREGATION_CREATE_OR_OPEN_OPTIONS.EXTERNAL;

pub const CONTACT_AGGREGATION_COLLECTION_OPTIONS = enum(i32) {
    DEFAULT = 0,
    INCLUDE_EXTERNAL = 1,
    EXTERNAL_ONLY = 2,
};
pub const CACO_DEFAULT = CONTACT_AGGREGATION_COLLECTION_OPTIONS.DEFAULT;
pub const CACO_INCLUDE_EXTERNAL = CONTACT_AGGREGATION_COLLECTION_OPTIONS.INCLUDE_EXTERNAL;
pub const CACO_EXTERNAL_ONLY = CONTACT_AGGREGATION_COLLECTION_OPTIONS.EXTERNAL_ONLY;

pub const CONTACT_AGGREGATION_BLOB = extern struct {
    dwCount: u32,
    lpb: ?*u8,
};

const IID_IContactAggregationManager_Value = Guid.initString("1d865989-4b1f-4b60-8f34-c2ad468b2b50");
pub const IID_IContactAggregationManager = &IID_IContactAggregationManager_Value;
pub const IContactAggregationManager = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetVersionInfo: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationManager,
                plMajorVersion: ?*i32,
                plMinorVersion: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationManager,
                plMajorVersion: ?*i32,
                plMinorVersion: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateOrOpenGroup: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationManager,
                pGroupName: ?[*:0]const u16,
                options: CONTACT_AGGREGATION_CREATE_OR_OPEN_OPTIONS,
                pCreatedGroup: ?*BOOL,
                ppGroup: ?*?*IContactAggregationGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationManager,
                pGroupName: ?[*:0]const u16,
                options: CONTACT_AGGREGATION_CREATE_OR_OPEN_OPTIONS,
                pCreatedGroup: ?*BOOL,
                ppGroup: ?*?*IContactAggregationGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateExternalContact: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationManager,
                ppItem: ?*?*IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationManager,
                ppItem: ?*?*IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateServerPerson: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationManager,
                ppServerPerson: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationManager,
                ppServerPerson: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateServerContactLink: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationManager,
                ppServerContactLink: ?*?*IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationManager,
                ppServerContactLink: ?*?*IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Flush: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OpenAggregateContact: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationManager,
                pItemId: ?[*:0]const u16,
                ppItem: ?*?*IContactAggregationAggregate,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationManager,
                pItemId: ?[*:0]const u16,
                ppItem: ?*?*IContactAggregationAggregate,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OpenContact: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationManager,
                pItemId: ?[*:0]const u16,
                ppItem: ?*?*IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationManager,
                pItemId: ?[*:0]const u16,
                ppItem: ?*?*IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OpenServerContactLink: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationManager,
                pItemId: ?[*:0]const u16,
                ppItem: ?*?*IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationManager,
                pItemId: ?[*:0]const u16,
                ppItem: ?*?*IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OpenServerPerson: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationManager,
                pItemId: ?[*:0]const u16,
                ppItem: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationManager,
                pItemId: ?[*:0]const u16,
                ppItem: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Contacts: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationManager,
                options: CONTACT_AGGREGATION_COLLECTION_OPTIONS,
                ppItems: ?*?*IContactAggregationContactCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationManager,
                options: CONTACT_AGGREGATION_COLLECTION_OPTIONS,
                ppItems: ?*?*IContactAggregationContactCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_AggregateContacts: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationManager,
                options: CONTACT_AGGREGATION_COLLECTION_OPTIONS,
                ppAggregates: ?*?*IContactAggregationAggregateCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationManager,
                options: CONTACT_AGGREGATION_COLLECTION_OPTIONS,
                ppAggregates: ?*?*IContactAggregationAggregateCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Groups: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationManager,
                options: CONTACT_AGGREGATION_COLLECTION_OPTIONS,
                ppGroups: ?*?*IContactAggregationGroupCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationManager,
                options: CONTACT_AGGREGATION_COLLECTION_OPTIONS,
                ppGroups: ?*?*IContactAggregationGroupCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ServerPersons: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationManager,
                ppServerPersonCollection: ?*?*IContactAggregationServerPersonCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationManager,
                ppServerPersonCollection: ?*?*IContactAggregationServerPersonCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ServerContactLinks: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationManager,
                pPersonItemId: ?[*:0]const u16,
                ppServerContactLinkCollection: ?*?*IContactAggregationLinkCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationManager,
                pPersonItemId: ?[*:0]const u16,
                ppServerContactLinkCollection: ?*?*IContactAggregationLinkCollection,
            ) 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 IContactAggregationManager_GetVersionInfo(self: *const T, plMajorVersion: ?*i32, plMinorVersion: ?*i32) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).GetVersionInfo(@as(*const IContactAggregationManager, @ptrCast(self)), plMajorVersion, plMinorVersion);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_CreateOrOpenGroup(self: *const T, pGroupName: ?[*:0]const u16, options: CONTACT_AGGREGATION_CREATE_OR_OPEN_OPTIONS, pCreatedGroup: ?*BOOL, ppGroup: ?*?*IContactAggregationGroup) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).CreateOrOpenGroup(@as(*const IContactAggregationManager, @ptrCast(self)), pGroupName, options, pCreatedGroup, ppGroup);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_CreateExternalContact(self: *const T, ppItem: ?*?*IContactAggregationContact) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).CreateExternalContact(@as(*const IContactAggregationManager, @ptrCast(self)), ppItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_CreateServerPerson(self: *const T, ppServerPerson: ?*?*IContactAggregationServerPerson) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).CreateServerPerson(@as(*const IContactAggregationManager, @ptrCast(self)), ppServerPerson);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_CreateServerContactLink(self: *const T, ppServerContactLink: ?*?*IContactAggregationLink) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).CreateServerContactLink(@as(*const IContactAggregationManager, @ptrCast(self)), ppServerContactLink);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_Flush(self: *const T) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).Flush(@as(*const IContactAggregationManager, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_OpenAggregateContact(self: *const T, pItemId: ?[*:0]const u16, ppItem: ?*?*IContactAggregationAggregate) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).OpenAggregateContact(@as(*const IContactAggregationManager, @ptrCast(self)), pItemId, ppItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_OpenContact(self: *const T, pItemId: ?[*:0]const u16, ppItem: ?*?*IContactAggregationContact) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).OpenContact(@as(*const IContactAggregationManager, @ptrCast(self)), pItemId, ppItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_OpenServerContactLink(self: *const T, pItemId: ?[*:0]const u16, ppItem: ?*?*IContactAggregationLink) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).OpenServerContactLink(@as(*const IContactAggregationManager, @ptrCast(self)), pItemId, ppItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_OpenServerPerson(self: *const T, pItemId: ?[*:0]const u16, ppItem: ?*?*IContactAggregationServerPerson) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).OpenServerPerson(@as(*const IContactAggregationManager, @ptrCast(self)), pItemId, ppItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_get_Contacts(self: *const T, options: CONTACT_AGGREGATION_COLLECTION_OPTIONS, ppItems: ?*?*IContactAggregationContactCollection) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).get_Contacts(@as(*const IContactAggregationManager, @ptrCast(self)), options, ppItems);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_get_AggregateContacts(self: *const T, options: CONTACT_AGGREGATION_COLLECTION_OPTIONS, ppAggregates: ?*?*IContactAggregationAggregateCollection) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).get_AggregateContacts(@as(*const IContactAggregationManager, @ptrCast(self)), options, ppAggregates);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_get_Groups(self: *const T, options: CONTACT_AGGREGATION_COLLECTION_OPTIONS, ppGroups: ?*?*IContactAggregationGroupCollection) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).get_Groups(@as(*const IContactAggregationManager, @ptrCast(self)), options, ppGroups);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_get_ServerPersons(self: *const T, ppServerPersonCollection: ?*?*IContactAggregationServerPersonCollection) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).get_ServerPersons(@as(*const IContactAggregationManager, @ptrCast(self)), ppServerPersonCollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationManager_get_ServerContactLinks(self: *const T, pPersonItemId: ?[*:0]const u16, ppServerContactLinkCollection: ?*?*IContactAggregationLinkCollection) HRESULT {
                return @as(*const IContactAggregationManager.VTable, @ptrCast(self.vtable)).get_ServerContactLinks(@as(*const IContactAggregationManager, @ptrCast(self)), pPersonItemId, ppServerContactLinkCollection);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IContactAggregationContact_Value = Guid.initString("1eb22e86-4c86-41f0-9f9f-c251e9fda6c3");
pub const IID_IContactAggregationContact = &IID_IContactAggregationContact_Value;
pub const IContactAggregationContact = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Save: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MoveToAggregate: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationContact,
                pAggregateId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationContact,
                pAggregateId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Unlink: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_AccountId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                ppAccountId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                ppAccountId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_AccountId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                pAccountId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                pAccountId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_AggregateId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                ppAggregateId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                ppAggregateId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Id: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                ppItemId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                ppItemId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_IsMe: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                pIsMe: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                pIsMe: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_IsExternal: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                pIsExternal: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                pIsExternal: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_NetworkSourceId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                pNetworkSourceId: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                pNetworkSourceId: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_NetworkSourceId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                networkSourceId: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                networkSourceId: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_NetworkSourceIdString: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                ppNetworkSourceId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                ppNetworkSourceId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_NetworkSourceIdString: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                pNetworkSourceId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                pNetworkSourceId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_RemoteObjectId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                ppRemoteObjectId: ?*?*CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                ppRemoteObjectId: ?*?*CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_RemoteObjectId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SyncIdentityHash: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                ppSyncIdentityHash: ?*?*CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                ppSyncIdentityHash: ?*?*CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_SyncIdentityHash: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContact,
                pSyncIdentityHash: ?*const CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContact,
                pSyncIdentityHash: ?*const CONTACT_AGGREGATION_BLOB,
            ) 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 IContactAggregationContact_Delete(self: *const T) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).Delete(@as(*const IContactAggregationContact, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_Save(self: *const T) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).Save(@as(*const IContactAggregationContact, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_MoveToAggregate(self: *const T, pAggregateId: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).MoveToAggregate(@as(*const IContactAggregationContact, @ptrCast(self)), pAggregateId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_Unlink(self: *const T) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).Unlink(@as(*const IContactAggregationContact, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_get_AccountId(self: *const T, ppAccountId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).get_AccountId(@as(*const IContactAggregationContact, @ptrCast(self)), ppAccountId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_put_AccountId(self: *const T, pAccountId: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).put_AccountId(@as(*const IContactAggregationContact, @ptrCast(self)), pAccountId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_get_AggregateId(self: *const T, ppAggregateId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).get_AggregateId(@as(*const IContactAggregationContact, @ptrCast(self)), ppAggregateId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_get_Id(self: *const T, ppItemId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).get_Id(@as(*const IContactAggregationContact, @ptrCast(self)), ppItemId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_get_IsMe(self: *const T, pIsMe: ?*BOOL) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).get_IsMe(@as(*const IContactAggregationContact, @ptrCast(self)), pIsMe);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_get_IsExternal(self: *const T, pIsExternal: ?*BOOL) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).get_IsExternal(@as(*const IContactAggregationContact, @ptrCast(self)), pIsExternal);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_get_NetworkSourceId(self: *const T, pNetworkSourceId: ?*u32) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).get_NetworkSourceId(@as(*const IContactAggregationContact, @ptrCast(self)), pNetworkSourceId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_put_NetworkSourceId(self: *const T, networkSourceId: u32) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).put_NetworkSourceId(@as(*const IContactAggregationContact, @ptrCast(self)), networkSourceId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_get_NetworkSourceIdString(self: *const T, ppNetworkSourceId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).get_NetworkSourceIdString(@as(*const IContactAggregationContact, @ptrCast(self)), ppNetworkSourceId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_put_NetworkSourceIdString(self: *const T, pNetworkSourceId: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).put_NetworkSourceIdString(@as(*const IContactAggregationContact, @ptrCast(self)), pNetworkSourceId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_get_RemoteObjectId(self: *const T, ppRemoteObjectId: ?*?*CONTACT_AGGREGATION_BLOB) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).get_RemoteObjectId(@as(*const IContactAggregationContact, @ptrCast(self)), ppRemoteObjectId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_put_RemoteObjectId(self: *const T, pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).put_RemoteObjectId(@as(*const IContactAggregationContact, @ptrCast(self)), pRemoteObjectId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_get_SyncIdentityHash(self: *const T, ppSyncIdentityHash: ?*?*CONTACT_AGGREGATION_BLOB) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).get_SyncIdentityHash(@as(*const IContactAggregationContact, @ptrCast(self)), ppSyncIdentityHash);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContact_put_SyncIdentityHash(self: *const T, pSyncIdentityHash: ?*const CONTACT_AGGREGATION_BLOB) HRESULT {
                return @as(*const IContactAggregationContact.VTable, @ptrCast(self.vtable)).put_SyncIdentityHash(@as(*const IContactAggregationContact, @ptrCast(self)), pSyncIdentityHash);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IContactAggregationContactCollection_Value = Guid.initString("826e66fa-81de-43ca-a6fb-8c785cd996c6");
pub const IID_IContactAggregationContactCollection = &IID_IContactAggregationContactCollection_Value;
pub const IContactAggregationContactCollection = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        FindFirst: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationContactCollection,
                ppItem: ?*?*IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationContactCollection,
                ppItem: ?*?*IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindNext: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationContactCollection,
                ppItem: ?*?*IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationContactCollection,
                ppItem: ?*?*IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindFirstByIdentityHash: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationContactCollection,
                pSourceType: ?[*:0]const u16,
                pAccountId: ?[*:0]const u16,
                pIdentityHash: ?*const CONTACT_AGGREGATION_BLOB,
                ppItem: ?*?*IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationContactCollection,
                pSourceType: ?[*:0]const u16,
                pAccountId: ?[*:0]const u16,
                pIdentityHash: ?*const CONTACT_AGGREGATION_BLOB,
                ppItem: ?*?*IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationContactCollection,
                pCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationContactCollection,
                pCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindFirstByRemoteId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationContactCollection,
                pSourceType: ?[*:0]const u16,
                pAccountId: ?[*:0]const u16,
                pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB,
                ppItem: ?*?*IContactAggregationContact,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationContactCollection,
                pSourceType: ?[*:0]const u16,
                pAccountId: ?[*:0]const u16,
                pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB,
                ppItem: ?*?*IContactAggregationContact,
            ) 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 IContactAggregationContactCollection_FindFirst(self: *const T, ppItem: ?*?*IContactAggregationContact) HRESULT {
                return @as(*const IContactAggregationContactCollection.VTable, @ptrCast(self.vtable)).FindFirst(@as(*const IContactAggregationContactCollection, @ptrCast(self)), ppItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContactCollection_FindNext(self: *const T, ppItem: ?*?*IContactAggregationContact) HRESULT {
                return @as(*const IContactAggregationContactCollection.VTable, @ptrCast(self.vtable)).FindNext(@as(*const IContactAggregationContactCollection, @ptrCast(self)), ppItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContactCollection_FindFirstByIdentityHash(self: *const T, pSourceType: ?[*:0]const u16, pAccountId: ?[*:0]const u16, pIdentityHash: ?*const CONTACT_AGGREGATION_BLOB, ppItem: ?*?*IContactAggregationContact) HRESULT {
                return @as(*const IContactAggregationContactCollection.VTable, @ptrCast(self.vtable)).FindFirstByIdentityHash(@as(*const IContactAggregationContactCollection, @ptrCast(self)), pSourceType, pAccountId, pIdentityHash, ppItem);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContactCollection_get_Count(self: *const T, pCount: ?*i32) HRESULT {
                return @as(*const IContactAggregationContactCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IContactAggregationContactCollection, @ptrCast(self)), pCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationContactCollection_FindFirstByRemoteId(self: *const T, pSourceType: ?[*:0]const u16, pAccountId: ?[*:0]const u16, pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB, ppItem: ?*?*IContactAggregationContact) HRESULT {
                return @as(*const IContactAggregationContactCollection.VTable, @ptrCast(self.vtable)).FindFirstByRemoteId(@as(*const IContactAggregationContactCollection, @ptrCast(self)), pSourceType, pAccountId, pRemoteObjectId, ppItem);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IContactAggregationAggregate_Value = Guid.initString("7ed1c814-cd30-43c8-9b8d-2e489e53d54b");
pub const IID_IContactAggregationAggregate = &IID_IContactAggregationAggregate_Value;
pub const IContactAggregationAggregate = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Save: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationAggregate,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationAggregate,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetComponentItems: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationAggregate,
                pComponentItems: ?*?*IContactAggregationContactCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationAggregate,
                pComponentItems: ?*?*IContactAggregationContactCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Link: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationAggregate,
                pAggregateId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationAggregate,
                pAggregateId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Groups: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationAggregate,
                options: CONTACT_AGGREGATION_COLLECTION_OPTIONS,
                ppGroups: ?*?*IContactAggregationGroupCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationAggregate,
                options: CONTACT_AGGREGATION_COLLECTION_OPTIONS,
                ppGroups: ?*?*IContactAggregationGroupCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_AntiLink: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationAggregate,
                ppAntiLink: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationAggregate,
                ppAntiLink: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_AntiLink: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationAggregate,
                pAntiLink: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationAggregate,
                pAntiLink: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_FavoriteOrder: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationAggregate,
                pFavoriteOrder: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationAggregate,
                pFavoriteOrder: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_FavoriteOrder: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationAggregate,
                favoriteOrder: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationAggregate,
                favoriteOrder: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Id: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationAggregate,
                ppItemId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationAggregate,
                ppItemId: ?*?PWSTR,
            ) 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 IContactAggregationAggregate_Save(self: *const T) HRESULT {
                return @as(*const IContactAggregationAggregate.VTable, @ptrCast(self.vtable)).Save(@as(*const IContactAggregationAggregate, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationAggregate_GetComponentItems(self: *const T, pComponentItems: ?*?*IContactAggregationContactCollection) HRESULT {
                return @as(*const IContactAggregationAggregate.VTable, @ptrCast(self.vtable)).GetComponentItems(@as(*const IContactAggregationAggregate, @ptrCast(self)), pComponentItems);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationAggregate_Link(self: *const T, pAggregateId: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationAggregate.VTable, @ptrCast(self.vtable)).Link(@as(*const IContactAggregationAggregate, @ptrCast(self)), pAggregateId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationAggregate_get_Groups(self: *const T, options: CONTACT_AGGREGATION_COLLECTION_OPTIONS, ppGroups: ?*?*IContactAggregationGroupCollection) HRESULT {
                return @as(*const IContactAggregationAggregate.VTable, @ptrCast(self.vtable)).get_Groups(@as(*const IContactAggregationAggregate, @ptrCast(self)), options, ppGroups);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationAggregate_get_AntiLink(self: *const T, ppAntiLink: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationAggregate.VTable, @ptrCast(self.vtable)).get_AntiLink(@as(*const IContactAggregationAggregate, @ptrCast(self)), ppAntiLink);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationAggregate_put_AntiLink(self: *const T, pAntiLink: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationAggregate.VTable, @ptrCast(self.vtable)).put_AntiLink(@as(*const IContactAggregationAggregate, @ptrCast(self)), pAntiLink);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationAggregate_get_FavoriteOrder(self: *const T, pFavoriteOrder: ?*u32) HRESULT {
                return @as(*const IContactAggregationAggregate.VTable, @ptrCast(self.vtable)).get_FavoriteOrder(@as(*const IContactAggregationAggregate, @ptrCast(self)), pFavoriteOrder);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationAggregate_put_FavoriteOrder(self: *const T, favoriteOrder: u32) HRESULT {
                return @as(*const IContactAggregationAggregate.VTable, @ptrCast(self.vtable)).put_FavoriteOrder(@as(*const IContactAggregationAggregate, @ptrCast(self)), favoriteOrder);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationAggregate_get_Id(self: *const T, ppItemId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationAggregate.VTable, @ptrCast(self.vtable)).get_Id(@as(*const IContactAggregationAggregate, @ptrCast(self)), ppItemId);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IContactAggregationAggregateCollection_Value = Guid.initString("2359f3a6-3a68-40af-98db-0f9eb143c3bb");
pub const IID_IContactAggregationAggregateCollection = &IID_IContactAggregationAggregateCollection_Value;
pub const IContactAggregationAggregateCollection = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        FindFirst: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationAggregateCollection,
                ppAggregate: ?*?*IContactAggregationAggregate,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationAggregateCollection,
                ppAggregate: ?*?*IContactAggregationAggregate,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindFirstByAntiLinkId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationAggregateCollection,
                pAntiLinkId: ?[*:0]const u16,
                ppAggregate: ?*?*IContactAggregationAggregate,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationAggregateCollection,
                pAntiLinkId: ?[*:0]const u16,
                ppAggregate: ?*?*IContactAggregationAggregate,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindNext: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationAggregateCollection,
                ppAggregate: ?*?*IContactAggregationAggregate,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationAggregateCollection,
                ppAggregate: ?*?*IContactAggregationAggregate,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationAggregateCollection,
                pCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationAggregateCollection,
                pCount: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationAggregateCollection_FindFirst(self: *const T, ppAggregate: ?*?*IContactAggregationAggregate) HRESULT {
                return @as(*const IContactAggregationAggregateCollection.VTable, @ptrCast(self.vtable)).FindFirst(@as(*const IContactAggregationAggregateCollection, @ptrCast(self)), ppAggregate);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationAggregateCollection_FindFirstByAntiLinkId(self: *const T, pAntiLinkId: ?[*:0]const u16, ppAggregate: ?*?*IContactAggregationAggregate) HRESULT {
                return @as(*const IContactAggregationAggregateCollection.VTable, @ptrCast(self.vtable)).FindFirstByAntiLinkId(@as(*const IContactAggregationAggregateCollection, @ptrCast(self)), pAntiLinkId, ppAggregate);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationAggregateCollection_FindNext(self: *const T, ppAggregate: ?*?*IContactAggregationAggregate) HRESULT {
                return @as(*const IContactAggregationAggregateCollection.VTable, @ptrCast(self.vtable)).FindNext(@as(*const IContactAggregationAggregateCollection, @ptrCast(self)), ppAggregate);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationAggregateCollection_get_Count(self: *const T, pCount: ?*i32) HRESULT {
                return @as(*const IContactAggregationAggregateCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IContactAggregationAggregateCollection, @ptrCast(self)), pCount);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IContactAggregationGroup_Value = Guid.initString("c93c545f-1284-499b-96af-07372af473e0");
pub const IID_IContactAggregationGroup = &IID_IContactAggregationGroup_Value;
pub const IContactAggregationGroup = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Save: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Add: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationGroup,
                pAggregateId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationGroup,
                pAggregateId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Remove: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationGroup,
                pAggregateId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationGroup,
                pAggregateId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Members: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationGroup,
                ppAggregateContactCollection: ?*?*IContactAggregationAggregateCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationGroup,
                ppAggregateContactCollection: ?*?*IContactAggregationAggregateCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_GlobalObjectId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationGroup,
                pGlobalObjectId: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationGroup,
                pGlobalObjectId: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_GlobalObjectId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationGroup,
                pGlobalObjectId: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationGroup,
                pGlobalObjectId: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Id: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationGroup,
                ppItemId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationGroup,
                ppItemId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Name: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationGroup,
                ppName: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationGroup,
                ppName: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Name: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationGroup,
                pName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationGroup,
                pName: ?[*: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 IContactAggregationGroup_Delete(self: *const T) HRESULT {
                return @as(*const IContactAggregationGroup.VTable, @ptrCast(self.vtable)).Delete(@as(*const IContactAggregationGroup, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationGroup_Save(self: *const T) HRESULT {
                return @as(*const IContactAggregationGroup.VTable, @ptrCast(self.vtable)).Save(@as(*const IContactAggregationGroup, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationGroup_Add(self: *const T, pAggregateId: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationGroup.VTable, @ptrCast(self.vtable)).Add(@as(*const IContactAggregationGroup, @ptrCast(self)), pAggregateId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationGroup_Remove(self: *const T, pAggregateId: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationGroup.VTable, @ptrCast(self.vtable)).Remove(@as(*const IContactAggregationGroup, @ptrCast(self)), pAggregateId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationGroup_get_Members(self: *const T, ppAggregateContactCollection: ?*?*IContactAggregationAggregateCollection) HRESULT {
                return @as(*const IContactAggregationGroup.VTable, @ptrCast(self.vtable)).get_Members(@as(*const IContactAggregationGroup, @ptrCast(self)), ppAggregateContactCollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationGroup_get_GlobalObjectId(self: *const T, pGlobalObjectId: ?*Guid) HRESULT {
                return @as(*const IContactAggregationGroup.VTable, @ptrCast(self.vtable)).get_GlobalObjectId(@as(*const IContactAggregationGroup, @ptrCast(self)), pGlobalObjectId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationGroup_put_GlobalObjectId(self: *const T, pGlobalObjectId: ?*const Guid) HRESULT {
                return @as(*const IContactAggregationGroup.VTable, @ptrCast(self.vtable)).put_GlobalObjectId(@as(*const IContactAggregationGroup, @ptrCast(self)), pGlobalObjectId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationGroup_get_Id(self: *const T, ppItemId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationGroup.VTable, @ptrCast(self.vtable)).get_Id(@as(*const IContactAggregationGroup, @ptrCast(self)), ppItemId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationGroup_get_Name(self: *const T, ppName: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationGroup.VTable, @ptrCast(self.vtable)).get_Name(@as(*const IContactAggregationGroup, @ptrCast(self)), ppName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationGroup_put_Name(self: *const T, pName: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationGroup.VTable, @ptrCast(self.vtable)).put_Name(@as(*const IContactAggregationGroup, @ptrCast(self)), pName);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IContactAggregationGroupCollection_Value = Guid.initString("20a19a9c-d2f3-4b83-9143-beffd2cc226d");
pub const IID_IContactAggregationGroupCollection = &IID_IContactAggregationGroupCollection_Value;
pub const IContactAggregationGroupCollection = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        FindFirst: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationGroupCollection,
                ppGroup: ?*?*IContactAggregationGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationGroupCollection,
                ppGroup: ?*?*IContactAggregationGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindFirstByGlobalObjectId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationGroupCollection,
                pGlobalObjectId: ?*const Guid,
                ppGroup: ?*?*IContactAggregationGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationGroupCollection,
                pGlobalObjectId: ?*const Guid,
                ppGroup: ?*?*IContactAggregationGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindNext: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationGroupCollection,
                ppGroup: ?*?*IContactAggregationGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationGroupCollection,
                ppGroup: ?*?*IContactAggregationGroup,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationGroupCollection,
                pCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationGroupCollection,
                pCount: ?*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 IContactAggregationGroupCollection_FindFirst(self: *const T, ppGroup: ?*?*IContactAggregationGroup) HRESULT {
                return @as(*const IContactAggregationGroupCollection.VTable, @ptrCast(self.vtable)).FindFirst(@as(*const IContactAggregationGroupCollection, @ptrCast(self)), ppGroup);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationGroupCollection_FindFirstByGlobalObjectId(self: *const T, pGlobalObjectId: ?*const Guid, ppGroup: ?*?*IContactAggregationGroup) HRESULT {
                return @as(*const IContactAggregationGroupCollection.VTable, @ptrCast(self.vtable)).FindFirstByGlobalObjectId(@as(*const IContactAggregationGroupCollection, @ptrCast(self)), pGlobalObjectId, ppGroup);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationGroupCollection_FindNext(self: *const T, ppGroup: ?*?*IContactAggregationGroup) HRESULT {
                return @as(*const IContactAggregationGroupCollection.VTable, @ptrCast(self.vtable)).FindNext(@as(*const IContactAggregationGroupCollection, @ptrCast(self)), ppGroup);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationGroupCollection_get_Count(self: *const T, pCount: ?*u32) HRESULT {
                return @as(*const IContactAggregationGroupCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IContactAggregationGroupCollection, @ptrCast(self)), pCount);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IContactAggregationLink_Value = Guid.initString("b6813323-a183-4654-8627-79b30de3a0ec");
pub const IID_IContactAggregationLink = &IID_IContactAggregationLink_Value;
pub const IContactAggregationLink = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Save: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_AccountId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                ppAccountId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                ppAccountId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_AccountId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                pAccountId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                pAccountId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Id: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                ppItemId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                ppItemId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_IsLinkResolved: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                pIsLinkResolved: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                pIsLinkResolved: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_IsLinkResolved: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                isLinkResolved: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                isLinkResolved: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_NetworkSourceIdString: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                ppNetworkSourceId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                ppNetworkSourceId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_NetworkSourceIdString: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                pNetworkSourceId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                pNetworkSourceId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_RemoteObjectId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                ppRemoteObjectId: ?*?*CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                ppRemoteObjectId: ?*?*CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_RemoteObjectId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ServerPerson: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                ppServerPersonId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                ppServerPersonId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_ServerPerson: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                pServerPersonId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                pServerPersonId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ServerPersonBaseline: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                ppServerPersonId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                ppServerPersonId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_ServerPersonBaseline: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                pServerPersonId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                pServerPersonId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_SyncIdentityHash: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                ppSyncIdentityHash: ?*?*CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                ppSyncIdentityHash: ?*?*CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_SyncIdentityHash: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLink,
                pSyncIdentityHash: ?*const CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLink,
                pSyncIdentityHash: ?*const CONTACT_AGGREGATION_BLOB,
            ) 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 IContactAggregationLink_Delete(self: *const T) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).Delete(@as(*const IContactAggregationLink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_Save(self: *const T) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).Save(@as(*const IContactAggregationLink, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_get_AccountId(self: *const T, ppAccountId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).get_AccountId(@as(*const IContactAggregationLink, @ptrCast(self)), ppAccountId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_put_AccountId(self: *const T, pAccountId: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).put_AccountId(@as(*const IContactAggregationLink, @ptrCast(self)), pAccountId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_get_Id(self: *const T, ppItemId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).get_Id(@as(*const IContactAggregationLink, @ptrCast(self)), ppItemId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_get_IsLinkResolved(self: *const T, pIsLinkResolved: ?*BOOL) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).get_IsLinkResolved(@as(*const IContactAggregationLink, @ptrCast(self)), pIsLinkResolved);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_put_IsLinkResolved(self: *const T, isLinkResolved: BOOL) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).put_IsLinkResolved(@as(*const IContactAggregationLink, @ptrCast(self)), isLinkResolved);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_get_NetworkSourceIdString(self: *const T, ppNetworkSourceId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).get_NetworkSourceIdString(@as(*const IContactAggregationLink, @ptrCast(self)), ppNetworkSourceId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_put_NetworkSourceIdString(self: *const T, pNetworkSourceId: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).put_NetworkSourceIdString(@as(*const IContactAggregationLink, @ptrCast(self)), pNetworkSourceId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_get_RemoteObjectId(self: *const T, ppRemoteObjectId: ?*?*CONTACT_AGGREGATION_BLOB) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).get_RemoteObjectId(@as(*const IContactAggregationLink, @ptrCast(self)), ppRemoteObjectId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_put_RemoteObjectId(self: *const T, pRemoteObjectId: ?*const CONTACT_AGGREGATION_BLOB) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).put_RemoteObjectId(@as(*const IContactAggregationLink, @ptrCast(self)), pRemoteObjectId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_get_ServerPerson(self: *const T, ppServerPersonId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).get_ServerPerson(@as(*const IContactAggregationLink, @ptrCast(self)), ppServerPersonId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_put_ServerPerson(self: *const T, pServerPersonId: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).put_ServerPerson(@as(*const IContactAggregationLink, @ptrCast(self)), pServerPersonId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_get_ServerPersonBaseline(self: *const T, ppServerPersonId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).get_ServerPersonBaseline(@as(*const IContactAggregationLink, @ptrCast(self)), ppServerPersonId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_put_ServerPersonBaseline(self: *const T, pServerPersonId: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).put_ServerPersonBaseline(@as(*const IContactAggregationLink, @ptrCast(self)), pServerPersonId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_get_SyncIdentityHash(self: *const T, ppSyncIdentityHash: ?*?*CONTACT_AGGREGATION_BLOB) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).get_SyncIdentityHash(@as(*const IContactAggregationLink, @ptrCast(self)), ppSyncIdentityHash);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLink_put_SyncIdentityHash(self: *const T, pSyncIdentityHash: ?*const CONTACT_AGGREGATION_BLOB) HRESULT {
                return @as(*const IContactAggregationLink.VTable, @ptrCast(self.vtable)).put_SyncIdentityHash(@as(*const IContactAggregationLink, @ptrCast(self)), pSyncIdentityHash);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IContactAggregationLinkCollection_Value = Guid.initString("f8bc0e93-fb55-4f28-b9fa-b1c274153292");
pub const IID_IContactAggregationLinkCollection = &IID_IContactAggregationLinkCollection_Value;
pub const IContactAggregationLinkCollection = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        FindFirst: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationLinkCollection,
                ppServerContactLink: ?*?*IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationLinkCollection,
                ppServerContactLink: ?*?*IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindFirstByRemoteId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationLinkCollection,
                pSourceType: ?[*:0]const u16,
                pAccountId: ?[*:0]const u16,
                pRemoteId: ?*const CONTACT_AGGREGATION_BLOB,
                ppServerContactLink: ?*?*IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationLinkCollection,
                pSourceType: ?[*:0]const u16,
                pAccountId: ?[*:0]const u16,
                pRemoteId: ?*const CONTACT_AGGREGATION_BLOB,
                ppServerContactLink: ?*?*IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindNext: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationLinkCollection,
                ppServerContactLink: ?*?*IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationLinkCollection,
                ppServerContactLink: ?*?*IContactAggregationLink,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationLinkCollection,
                pCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationLinkCollection,
                pCount: ?*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 IContactAggregationLinkCollection_FindFirst(self: *const T, ppServerContactLink: ?*?*IContactAggregationLink) HRESULT {
                return @as(*const IContactAggregationLinkCollection.VTable, @ptrCast(self.vtable)).FindFirst(@as(*const IContactAggregationLinkCollection, @ptrCast(self)), ppServerContactLink);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLinkCollection_FindFirstByRemoteId(self: *const T, pSourceType: ?[*:0]const u16, pAccountId: ?[*:0]const u16, pRemoteId: ?*const CONTACT_AGGREGATION_BLOB, ppServerContactLink: ?*?*IContactAggregationLink) HRESULT {
                return @as(*const IContactAggregationLinkCollection.VTable, @ptrCast(self.vtable)).FindFirstByRemoteId(@as(*const IContactAggregationLinkCollection, @ptrCast(self)), pSourceType, pAccountId, pRemoteId, ppServerContactLink);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLinkCollection_FindNext(self: *const T, ppServerContactLink: ?*?*IContactAggregationLink) HRESULT {
                return @as(*const IContactAggregationLinkCollection.VTable, @ptrCast(self.vtable)).FindNext(@as(*const IContactAggregationLinkCollection, @ptrCast(self)), ppServerContactLink);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationLinkCollection_get_Count(self: *const T, pCount: ?*u32) HRESULT {
                return @as(*const IContactAggregationLinkCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IContactAggregationLinkCollection, @ptrCast(self)), pCount);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IContactAggregationServerPerson_Value = Guid.initString("7fdc3d4b-1b82-4334-85c5-25184ee5a5f2");
pub const IID_IContactAggregationServerPerson = &IID_IContactAggregationServerPerson_Value;
pub const IContactAggregationServerPerson = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Save: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_AggregateId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                ppAggregateId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                ppAggregateId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_AggregateId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                pAggregateId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                pAggregateId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_AntiLink: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                ppAntiLink: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                ppAntiLink: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_AntiLink: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                pAntiLink: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                pAntiLink: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_AntiLinkBaseline: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                ppAntiLink: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                ppAntiLink: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_AntiLinkBaseline: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                pAntiLink: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                pAntiLink: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_FavoriteOrder: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                pFavoriteOrder: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                pFavoriteOrder: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_FavoriteOrder: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                favoriteOrder: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                favoriteOrder: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_FavoriteOrderBaseline: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                pFavoriteOrder: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                pFavoriteOrder: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_FavoriteOrderBaseline: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                favoriteOrder: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                favoriteOrder: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Groups: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                pGroups: ?*?*CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                pGroups: ?*?*CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_Groups: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                pGroups: ?*const CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                pGroups: ?*const CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_GroupsBaseline: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                ppGroups: ?*?*CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                ppGroups: ?*?*CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_GroupsBaseline: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                pGroups: ?*const CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                pGroups: ?*const CONTACT_AGGREGATION_BLOB,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Id: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                ppId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                ppId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_IsTombstone: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                pIsTombstone: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                pIsTombstone: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_IsTombstone: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                isTombstone: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                isTombstone: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_LinkedAggregateId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                ppLinkedAggregateId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                ppLinkedAggregateId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_LinkedAggregateId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                pLinkedAggregateId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                pLinkedAggregateId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_ObjectId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                ppObjectId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                ppObjectId: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        put_ObjectId: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPerson,
                pObjectId: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPerson,
                pObjectId: ?[*: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 IContactAggregationServerPerson_Delete(self: *const T) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).Delete(@as(*const IContactAggregationServerPerson, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_Save(self: *const T) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).Save(@as(*const IContactAggregationServerPerson, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_get_AggregateId(self: *const T, ppAggregateId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).get_AggregateId(@as(*const IContactAggregationServerPerson, @ptrCast(self)), ppAggregateId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_put_AggregateId(self: *const T, pAggregateId: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).put_AggregateId(@as(*const IContactAggregationServerPerson, @ptrCast(self)), pAggregateId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_get_AntiLink(self: *const T, ppAntiLink: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).get_AntiLink(@as(*const IContactAggregationServerPerson, @ptrCast(self)), ppAntiLink);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_put_AntiLink(self: *const T, pAntiLink: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).put_AntiLink(@as(*const IContactAggregationServerPerson, @ptrCast(self)), pAntiLink);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_get_AntiLinkBaseline(self: *const T, ppAntiLink: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).get_AntiLinkBaseline(@as(*const IContactAggregationServerPerson, @ptrCast(self)), ppAntiLink);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_put_AntiLinkBaseline(self: *const T, pAntiLink: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).put_AntiLinkBaseline(@as(*const IContactAggregationServerPerson, @ptrCast(self)), pAntiLink);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_get_FavoriteOrder(self: *const T, pFavoriteOrder: ?*u32) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).get_FavoriteOrder(@as(*const IContactAggregationServerPerson, @ptrCast(self)), pFavoriteOrder);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_put_FavoriteOrder(self: *const T, favoriteOrder: u32) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).put_FavoriteOrder(@as(*const IContactAggregationServerPerson, @ptrCast(self)), favoriteOrder);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_get_FavoriteOrderBaseline(self: *const T, pFavoriteOrder: ?*u32) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).get_FavoriteOrderBaseline(@as(*const IContactAggregationServerPerson, @ptrCast(self)), pFavoriteOrder);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_put_FavoriteOrderBaseline(self: *const T, favoriteOrder: u32) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).put_FavoriteOrderBaseline(@as(*const IContactAggregationServerPerson, @ptrCast(self)), favoriteOrder);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_get_Groups(self: *const T, pGroups: ?*?*CONTACT_AGGREGATION_BLOB) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).get_Groups(@as(*const IContactAggregationServerPerson, @ptrCast(self)), pGroups);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_put_Groups(self: *const T, pGroups: ?*const CONTACT_AGGREGATION_BLOB) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).put_Groups(@as(*const IContactAggregationServerPerson, @ptrCast(self)), pGroups);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_get_GroupsBaseline(self: *const T, ppGroups: ?*?*CONTACT_AGGREGATION_BLOB) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).get_GroupsBaseline(@as(*const IContactAggregationServerPerson, @ptrCast(self)), ppGroups);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_put_GroupsBaseline(self: *const T, pGroups: ?*const CONTACT_AGGREGATION_BLOB) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).put_GroupsBaseline(@as(*const IContactAggregationServerPerson, @ptrCast(self)), pGroups);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_get_Id(self: *const T, ppId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).get_Id(@as(*const IContactAggregationServerPerson, @ptrCast(self)), ppId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_get_IsTombstone(self: *const T, pIsTombstone: ?*BOOL) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).get_IsTombstone(@as(*const IContactAggregationServerPerson, @ptrCast(self)), pIsTombstone);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_put_IsTombstone(self: *const T, isTombstone: BOOL) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).put_IsTombstone(@as(*const IContactAggregationServerPerson, @ptrCast(self)), isTombstone);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_get_LinkedAggregateId(self: *const T, ppLinkedAggregateId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).get_LinkedAggregateId(@as(*const IContactAggregationServerPerson, @ptrCast(self)), ppLinkedAggregateId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_put_LinkedAggregateId(self: *const T, pLinkedAggregateId: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).put_LinkedAggregateId(@as(*const IContactAggregationServerPerson, @ptrCast(self)), pLinkedAggregateId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_get_ObjectId(self: *const T, ppObjectId: ?*?PWSTR) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).get_ObjectId(@as(*const IContactAggregationServerPerson, @ptrCast(self)), ppObjectId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPerson_put_ObjectId(self: *const T, pObjectId: ?[*:0]const u16) HRESULT {
                return @as(*const IContactAggregationServerPerson.VTable, @ptrCast(self.vtable)).put_ObjectId(@as(*const IContactAggregationServerPerson, @ptrCast(self)), pObjectId);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IContactAggregationServerPersonCollection_Value = Guid.initString("4f730a4a-6604-47b6-a987-669ecf1e5751");
pub const IID_IContactAggregationServerPersonCollection = &IID_IContactAggregationServerPersonCollection_Value;
pub const IContactAggregationServerPersonCollection = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        FindFirst: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationServerPersonCollection,
                ppServerPerson: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationServerPersonCollection,
                ppServerPerson: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindFirstByServerId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationServerPersonCollection,
                pServerId: ?[*:0]const u16,
                ppServerPerson: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationServerPersonCollection,
                pServerId: ?[*:0]const u16,
                ppServerPerson: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindFirstByAggregateId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationServerPersonCollection,
                pAggregateId: ?[*:0]const u16,
                ppServerPerson: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationServerPersonCollection,
                pAggregateId: ?[*:0]const u16,
                ppServerPerson: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindFirstByLinkedAggregateId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationServerPersonCollection,
                pAggregateId: ?[*:0]const u16,
                ppServerPerson: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationServerPersonCollection,
                pAggregateId: ?[*:0]const u16,
                ppServerPerson: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        FindNext: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IContactAggregationServerPersonCollection,
                ppServerPerson: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IContactAggregationServerPersonCollection,
                ppServerPerson: ?*?*IContactAggregationServerPerson,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        // TODO: this function has a "SpecialName", should Zig do anything with this?
        get_Count: switch (@import("builtin").zig_backend) {
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            .stage1 => fn (
                self: *const IContactAggregationServerPersonCollection,
                pCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            // TODO: this function has a "SpecialName", should Zig do anything with this?
            else => *const fn (
                self: *const IContactAggregationServerPersonCollection,
                pCount: ?*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 IContactAggregationServerPersonCollection_FindFirst(self: *const T, ppServerPerson: ?*?*IContactAggregationServerPerson) HRESULT {
                return @as(*const IContactAggregationServerPersonCollection.VTable, @ptrCast(self.vtable)).FindFirst(@as(*const IContactAggregationServerPersonCollection, @ptrCast(self)), ppServerPerson);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPersonCollection_FindFirstByServerId(self: *const T, pServerId: ?[*:0]const u16, ppServerPerson: ?*?*IContactAggregationServerPerson) HRESULT {
                return @as(*const IContactAggregationServerPersonCollection.VTable, @ptrCast(self.vtable)).FindFirstByServerId(@as(*const IContactAggregationServerPersonCollection, @ptrCast(self)), pServerId, ppServerPerson);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPersonCollection_FindFirstByAggregateId(self: *const T, pAggregateId: ?[*:0]const u16, ppServerPerson: ?*?*IContactAggregationServerPerson) HRESULT {
                return @as(*const IContactAggregationServerPersonCollection.VTable, @ptrCast(self.vtable)).FindFirstByAggregateId(@as(*const IContactAggregationServerPersonCollection, @ptrCast(self)), pAggregateId, ppServerPerson);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPersonCollection_FindFirstByLinkedAggregateId(self: *const T, pAggregateId: ?[*:0]const u16, ppServerPerson: ?*?*IContactAggregationServerPerson) HRESULT {
                return @as(*const IContactAggregationServerPersonCollection.VTable, @ptrCast(self.vtable)).FindFirstByLinkedAggregateId(@as(*const IContactAggregationServerPersonCollection, @ptrCast(self)), pAggregateId, ppServerPerson);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPersonCollection_FindNext(self: *const T, ppServerPerson: ?*?*IContactAggregationServerPerson) HRESULT {
                return @as(*const IContactAggregationServerPersonCollection.VTable, @ptrCast(self.vtable)).FindNext(@as(*const IContactAggregationServerPersonCollection, @ptrCast(self)), ppServerPerson);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IContactAggregationServerPersonCollection_get_Count(self: *const T, pCount: ?*u32) HRESULT {
                return @as(*const IContactAggregationServerPersonCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IContactAggregationServerPersonCollection, @ptrCast(self)), pCount);
            }
        };
    }
    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 (7)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const FILETIME = @import("../foundation.zig").FILETIME;
const HRESULT = @import("../foundation.zig").HRESULT;
const IStream = @import("../system/com.zig").IStream;
const IUnknown = @import("../system/com.zig").IUnknown;
const PWSTR = @import("../foundation.zig").PWSTR;

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);
        }
    }
}
