//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (3)
//--------------------------------------------------------------------------------
pub const _IID_IXmlReader = Guid.initString("7279fc81-709d-4095-b63d-69fe4b0d9030");
pub const _IID_IXmlWriter = Guid.initString("7279fc88-709d-4095-b63d-69fe4b0d9030");
pub const _IID_IXmlResolver = Guid.initString("7279fc82-709d-4095-b63d-69fe4b0d9030");

//--------------------------------------------------------------------------------
// Section: Types (12)
//--------------------------------------------------------------------------------
pub const XmlNodeType = enum(i32) {
    XmlNodeType_None = 0,
    XmlNodeType_Element = 1,
    XmlNodeType_Attribute = 2,
    XmlNodeType_Text = 3,
    XmlNodeType_CDATA = 4,
    XmlNodeType_ProcessingInstruction = 7,
    XmlNodeType_Comment = 8,
    XmlNodeType_DocumentType = 10,
    XmlNodeType_Whitespace = 13,
    XmlNodeType_EndElement = 15,
    XmlNodeType_XmlDeclaration = 17,
    // _XmlNodeType_Last = 17, this enum value conflicts with XmlNodeType_XmlDeclaration
};
pub const XmlNodeType_None = XmlNodeType.XmlNodeType_None;
pub const XmlNodeType_Element = XmlNodeType.XmlNodeType_Element;
pub const XmlNodeType_Attribute = XmlNodeType.XmlNodeType_Attribute;
pub const XmlNodeType_Text = XmlNodeType.XmlNodeType_Text;
pub const XmlNodeType_CDATA = XmlNodeType.XmlNodeType_CDATA;
pub const XmlNodeType_ProcessingInstruction = XmlNodeType.XmlNodeType_ProcessingInstruction;
pub const XmlNodeType_Comment = XmlNodeType.XmlNodeType_Comment;
pub const XmlNodeType_DocumentType = XmlNodeType.XmlNodeType_DocumentType;
pub const XmlNodeType_Whitespace = XmlNodeType.XmlNodeType_Whitespace;
pub const XmlNodeType_EndElement = XmlNodeType.XmlNodeType_EndElement;
pub const XmlNodeType_XmlDeclaration = XmlNodeType.XmlNodeType_XmlDeclaration;
pub const _XmlNodeType_Last = XmlNodeType.XmlNodeType_XmlDeclaration;

pub const XmlConformanceLevel = enum(i32) {
    XmlConformanceLevel_Auto = 0,
    XmlConformanceLevel_Fragment = 1,
    XmlConformanceLevel_Document = 2,
    // _XmlConformanceLevel_Last = 2, this enum value conflicts with XmlConformanceLevel_Document
};
pub const XmlConformanceLevel_Auto = XmlConformanceLevel.XmlConformanceLevel_Auto;
pub const XmlConformanceLevel_Fragment = XmlConformanceLevel.XmlConformanceLevel_Fragment;
pub const XmlConformanceLevel_Document = XmlConformanceLevel.XmlConformanceLevel_Document;
pub const _XmlConformanceLevel_Last = XmlConformanceLevel.XmlConformanceLevel_Document;

pub const DtdProcessing = enum(i32) {
    DtdProcessing_Prohibit = 0,
    DtdProcessing_Parse = 1,
    // _DtdProcessing_Last = 1, this enum value conflicts with DtdProcessing_Parse
};
pub const DtdProcessing_Prohibit = DtdProcessing.DtdProcessing_Prohibit;
pub const DtdProcessing_Parse = DtdProcessing.DtdProcessing_Parse;
pub const _DtdProcessing_Last = DtdProcessing.DtdProcessing_Parse;

pub const XmlReadState = enum(i32) {
    Initial = 0,
    Interactive = 1,
    Error = 2,
    EndOfFile = 3,
    Closed = 4,
};
pub const XmlReadState_Initial = XmlReadState.Initial;
pub const XmlReadState_Interactive = XmlReadState.Interactive;
pub const XmlReadState_Error = XmlReadState.Error;
pub const XmlReadState_EndOfFile = XmlReadState.EndOfFile;
pub const XmlReadState_Closed = XmlReadState.Closed;

pub const XmlReaderProperty = enum(i32) {
    XmlReaderProperty_MultiLanguage = 0,
    XmlReaderProperty_ConformanceLevel = 1,
    XmlReaderProperty_RandomAccess = 2,
    XmlReaderProperty_XmlResolver = 3,
    XmlReaderProperty_DtdProcessing = 4,
    XmlReaderProperty_ReadState = 5,
    XmlReaderProperty_MaxElementDepth = 6,
    XmlReaderProperty_MaxEntityExpansion = 7,
    // _XmlReaderProperty_Last = 7, this enum value conflicts with XmlReaderProperty_MaxEntityExpansion
};
pub const XmlReaderProperty_MultiLanguage = XmlReaderProperty.XmlReaderProperty_MultiLanguage;
pub const XmlReaderProperty_ConformanceLevel = XmlReaderProperty.XmlReaderProperty_ConformanceLevel;
pub const XmlReaderProperty_RandomAccess = XmlReaderProperty.XmlReaderProperty_RandomAccess;
pub const XmlReaderProperty_XmlResolver = XmlReaderProperty.XmlReaderProperty_XmlResolver;
pub const XmlReaderProperty_DtdProcessing = XmlReaderProperty.XmlReaderProperty_DtdProcessing;
pub const XmlReaderProperty_ReadState = XmlReaderProperty.XmlReaderProperty_ReadState;
pub const XmlReaderProperty_MaxElementDepth = XmlReaderProperty.XmlReaderProperty_MaxElementDepth;
pub const XmlReaderProperty_MaxEntityExpansion = XmlReaderProperty.XmlReaderProperty_MaxEntityExpansion;
pub const _XmlReaderProperty_Last = XmlReaderProperty.XmlReaderProperty_MaxEntityExpansion;

pub const XmlError = enum(i32) {
    MX_E_MX = -1072894464,
    MX_E_INPUTEND = -1072894463,
    MX_E_ENCODING = -1072894462,
    MX_E_ENCODINGSWITCH = -1072894461,
    MX_E_ENCODINGSIGNATURE = -1072894460,
    WC_E_WC = -1072894432,
    WC_E_WHITESPACE = -1072894431,
    WC_E_SEMICOLON = -1072894430,
    WC_E_GREATERTHAN = -1072894429,
    WC_E_QUOTE = -1072894428,
    WC_E_EQUAL = -1072894427,
    WC_E_LESSTHAN = -1072894426,
    WC_E_HEXDIGIT = -1072894425,
    WC_E_DIGIT = -1072894424,
    WC_E_LEFTBRACKET = -1072894423,
    WC_E_LEFTPAREN = -1072894422,
    WC_E_XMLCHARACTER = -1072894421,
    WC_E_NAMECHARACTER = -1072894420,
    WC_E_SYNTAX = -1072894419,
    WC_E_CDSECT = -1072894418,
    WC_E_COMMENT = -1072894417,
    WC_E_CONDSECT = -1072894416,
    WC_E_DECLATTLIST = -1072894415,
    WC_E_DECLDOCTYPE = -1072894414,
    WC_E_DECLELEMENT = -1072894413,
    WC_E_DECLENTITY = -1072894412,
    WC_E_DECLNOTATION = -1072894411,
    WC_E_NDATA = -1072894410,
    WC_E_PUBLIC = -1072894409,
    WC_E_SYSTEM = -1072894408,
    WC_E_NAME = -1072894407,
    WC_E_ROOTELEMENT = -1072894406,
    WC_E_ELEMENTMATCH = -1072894405,
    WC_E_UNIQUEATTRIBUTE = -1072894404,
    WC_E_TEXTXMLDECL = -1072894403,
    WC_E_LEADINGXML = -1072894402,
    WC_E_TEXTDECL = -1072894401,
    WC_E_XMLDECL = -1072894400,
    WC_E_ENCNAME = -1072894399,
    WC_E_PUBLICID = -1072894398,
    WC_E_PESINTERNALSUBSET = -1072894397,
    WC_E_PESBETWEENDECLS = -1072894396,
    WC_E_NORECURSION = -1072894395,
    WC_E_ENTITYCONTENT = -1072894394,
    WC_E_UNDECLAREDENTITY = -1072894393,
    WC_E_PARSEDENTITY = -1072894392,
    WC_E_NOEXTERNALENTITYREF = -1072894391,
    WC_E_PI = -1072894390,
    WC_E_SYSTEMID = -1072894389,
    WC_E_QUESTIONMARK = -1072894388,
    WC_E_CDSECTEND = -1072894387,
    WC_E_MOREDATA = -1072894386,
    WC_E_DTDPROHIBITED = -1072894385,
    WC_E_INVALIDXMLSPACE = -1072894384,
    NC_E_NC = -1072894368,
    NC_E_QNAMECHARACTER = -1072894367,
    NC_E_QNAMECOLON = -1072894366,
    NC_E_NAMECOLON = -1072894365,
    NC_E_DECLAREDPREFIX = -1072894364,
    NC_E_UNDECLAREDPREFIX = -1072894363,
    NC_E_EMPTYURI = -1072894362,
    NC_E_XMLPREFIXRESERVED = -1072894361,
    NC_E_XMLNSPREFIXRESERVED = -1072894360,
    NC_E_XMLURIRESERVED = -1072894359,
    NC_E_XMLNSURIRESERVED = -1072894358,
    SC_E_SC = -1072894336,
    SC_E_MAXELEMENTDEPTH = -1072894335,
    SC_E_MAXENTITYEXPANSION = -1072894334,
    WR_E_WR = -1072894208,
    WR_E_NONWHITESPACE = -1072894207,
    WR_E_NSPREFIXDECLARED = -1072894206,
    WR_E_NSPREFIXWITHEMPTYNSURI = -1072894205,
    WR_E_DUPLICATEATTRIBUTE = -1072894204,
    WR_E_XMLNSPREFIXDECLARATION = -1072894203,
    WR_E_XMLPREFIXDECLARATION = -1072894202,
    WR_E_XMLURIDECLARATION = -1072894201,
    WR_E_XMLNSURIDECLARATION = -1072894200,
    WR_E_NAMESPACEUNDECLARED = -1072894199,
    WR_E_INVALIDXMLSPACE = -1072894198,
    WR_E_INVALIDACTION = -1072894197,
    WR_E_INVALIDSURROGATEPAIR = -1072894196,
    XML_E_INVALID_DECIMAL = -1072898019,
    XML_E_INVALID_HEXIDECIMAL = -1072898018,
    XML_E_INVALID_UNICODE = -1072898017,
    XML_E_INVALIDENCODING = -1072897938,
};
pub const MX_E_MX = XmlError.MX_E_MX;
pub const MX_E_INPUTEND = XmlError.MX_E_INPUTEND;
pub const MX_E_ENCODING = XmlError.MX_E_ENCODING;
pub const MX_E_ENCODINGSWITCH = XmlError.MX_E_ENCODINGSWITCH;
pub const MX_E_ENCODINGSIGNATURE = XmlError.MX_E_ENCODINGSIGNATURE;
pub const WC_E_WC = XmlError.WC_E_WC;
pub const WC_E_WHITESPACE = XmlError.WC_E_WHITESPACE;
pub const WC_E_SEMICOLON = XmlError.WC_E_SEMICOLON;
pub const WC_E_GREATERTHAN = XmlError.WC_E_GREATERTHAN;
pub const WC_E_QUOTE = XmlError.WC_E_QUOTE;
pub const WC_E_EQUAL = XmlError.WC_E_EQUAL;
pub const WC_E_LESSTHAN = XmlError.WC_E_LESSTHAN;
pub const WC_E_HEXDIGIT = XmlError.WC_E_HEXDIGIT;
pub const WC_E_DIGIT = XmlError.WC_E_DIGIT;
pub const WC_E_LEFTBRACKET = XmlError.WC_E_LEFTBRACKET;
pub const WC_E_LEFTPAREN = XmlError.WC_E_LEFTPAREN;
pub const WC_E_XMLCHARACTER = XmlError.WC_E_XMLCHARACTER;
pub const WC_E_NAMECHARACTER = XmlError.WC_E_NAMECHARACTER;
pub const WC_E_SYNTAX = XmlError.WC_E_SYNTAX;
pub const WC_E_CDSECT = XmlError.WC_E_CDSECT;
pub const WC_E_COMMENT = XmlError.WC_E_COMMENT;
pub const WC_E_CONDSECT = XmlError.WC_E_CONDSECT;
pub const WC_E_DECLATTLIST = XmlError.WC_E_DECLATTLIST;
pub const WC_E_DECLDOCTYPE = XmlError.WC_E_DECLDOCTYPE;
pub const WC_E_DECLELEMENT = XmlError.WC_E_DECLELEMENT;
pub const WC_E_DECLENTITY = XmlError.WC_E_DECLENTITY;
pub const WC_E_DECLNOTATION = XmlError.WC_E_DECLNOTATION;
pub const WC_E_NDATA = XmlError.WC_E_NDATA;
pub const WC_E_PUBLIC = XmlError.WC_E_PUBLIC;
pub const WC_E_SYSTEM = XmlError.WC_E_SYSTEM;
pub const WC_E_NAME = XmlError.WC_E_NAME;
pub const WC_E_ROOTELEMENT = XmlError.WC_E_ROOTELEMENT;
pub const WC_E_ELEMENTMATCH = XmlError.WC_E_ELEMENTMATCH;
pub const WC_E_UNIQUEATTRIBUTE = XmlError.WC_E_UNIQUEATTRIBUTE;
pub const WC_E_TEXTXMLDECL = XmlError.WC_E_TEXTXMLDECL;
pub const WC_E_LEADINGXML = XmlError.WC_E_LEADINGXML;
pub const WC_E_TEXTDECL = XmlError.WC_E_TEXTDECL;
pub const WC_E_XMLDECL = XmlError.WC_E_XMLDECL;
pub const WC_E_ENCNAME = XmlError.WC_E_ENCNAME;
pub const WC_E_PUBLICID = XmlError.WC_E_PUBLICID;
pub const WC_E_PESINTERNALSUBSET = XmlError.WC_E_PESINTERNALSUBSET;
pub const WC_E_PESBETWEENDECLS = XmlError.WC_E_PESBETWEENDECLS;
pub const WC_E_NORECURSION = XmlError.WC_E_NORECURSION;
pub const WC_E_ENTITYCONTENT = XmlError.WC_E_ENTITYCONTENT;
pub const WC_E_UNDECLAREDENTITY = XmlError.WC_E_UNDECLAREDENTITY;
pub const WC_E_PARSEDENTITY = XmlError.WC_E_PARSEDENTITY;
pub const WC_E_NOEXTERNALENTITYREF = XmlError.WC_E_NOEXTERNALENTITYREF;
pub const WC_E_PI = XmlError.WC_E_PI;
pub const WC_E_SYSTEMID = XmlError.WC_E_SYSTEMID;
pub const WC_E_QUESTIONMARK = XmlError.WC_E_QUESTIONMARK;
pub const WC_E_CDSECTEND = XmlError.WC_E_CDSECTEND;
pub const WC_E_MOREDATA = XmlError.WC_E_MOREDATA;
pub const WC_E_DTDPROHIBITED = XmlError.WC_E_DTDPROHIBITED;
pub const WC_E_INVALIDXMLSPACE = XmlError.WC_E_INVALIDXMLSPACE;
pub const NC_E_NC = XmlError.NC_E_NC;
pub const NC_E_QNAMECHARACTER = XmlError.NC_E_QNAMECHARACTER;
pub const NC_E_QNAMECOLON = XmlError.NC_E_QNAMECOLON;
pub const NC_E_NAMECOLON = XmlError.NC_E_NAMECOLON;
pub const NC_E_DECLAREDPREFIX = XmlError.NC_E_DECLAREDPREFIX;
pub const NC_E_UNDECLAREDPREFIX = XmlError.NC_E_UNDECLAREDPREFIX;
pub const NC_E_EMPTYURI = XmlError.NC_E_EMPTYURI;
pub const NC_E_XMLPREFIXRESERVED = XmlError.NC_E_XMLPREFIXRESERVED;
pub const NC_E_XMLNSPREFIXRESERVED = XmlError.NC_E_XMLNSPREFIXRESERVED;
pub const NC_E_XMLURIRESERVED = XmlError.NC_E_XMLURIRESERVED;
pub const NC_E_XMLNSURIRESERVED = XmlError.NC_E_XMLNSURIRESERVED;
pub const SC_E_SC = XmlError.SC_E_SC;
pub const SC_E_MAXELEMENTDEPTH = XmlError.SC_E_MAXELEMENTDEPTH;
pub const SC_E_MAXENTITYEXPANSION = XmlError.SC_E_MAXENTITYEXPANSION;
pub const WR_E_WR = XmlError.WR_E_WR;
pub const WR_E_NONWHITESPACE = XmlError.WR_E_NONWHITESPACE;
pub const WR_E_NSPREFIXDECLARED = XmlError.WR_E_NSPREFIXDECLARED;
pub const WR_E_NSPREFIXWITHEMPTYNSURI = XmlError.WR_E_NSPREFIXWITHEMPTYNSURI;
pub const WR_E_DUPLICATEATTRIBUTE = XmlError.WR_E_DUPLICATEATTRIBUTE;
pub const WR_E_XMLNSPREFIXDECLARATION = XmlError.WR_E_XMLNSPREFIXDECLARATION;
pub const WR_E_XMLPREFIXDECLARATION = XmlError.WR_E_XMLPREFIXDECLARATION;
pub const WR_E_XMLURIDECLARATION = XmlError.WR_E_XMLURIDECLARATION;
pub const WR_E_XMLNSURIDECLARATION = XmlError.WR_E_XMLNSURIDECLARATION;
pub const WR_E_NAMESPACEUNDECLARED = XmlError.WR_E_NAMESPACEUNDECLARED;
pub const WR_E_INVALIDXMLSPACE = XmlError.WR_E_INVALIDXMLSPACE;
pub const WR_E_INVALIDACTION = XmlError.WR_E_INVALIDACTION;
pub const WR_E_INVALIDSURROGATEPAIR = XmlError.WR_E_INVALIDSURROGATEPAIR;
pub const XML_E_INVALID_DECIMAL = XmlError.XML_E_INVALID_DECIMAL;
pub const XML_E_INVALID_HEXIDECIMAL = XmlError.XML_E_INVALID_HEXIDECIMAL;
pub const XML_E_INVALID_UNICODE = XmlError.XML_E_INVALID_UNICODE;
pub const XML_E_INVALIDENCODING = XmlError.XML_E_INVALIDENCODING;

pub const XmlStandalone = enum(i32) {
    XmlStandalone_Omit = 0,
    XmlStandalone_Yes = 1,
    XmlStandalone_No = 2,
    // _XmlStandalone_Last = 2, this enum value conflicts with XmlStandalone_No
};
pub const XmlStandalone_Omit = XmlStandalone.XmlStandalone_Omit;
pub const XmlStandalone_Yes = XmlStandalone.XmlStandalone_Yes;
pub const XmlStandalone_No = XmlStandalone.XmlStandalone_No;
pub const _XmlStandalone_Last = XmlStandalone.XmlStandalone_No;

pub const XmlWriterProperty = enum(i32) {
    XmlWriterProperty_MultiLanguage = 0,
    XmlWriterProperty_Indent = 1,
    XmlWriterProperty_ByteOrderMark = 2,
    XmlWriterProperty_OmitXmlDeclaration = 3,
    XmlWriterProperty_ConformanceLevel = 4,
    XmlWriterProperty_CompactEmptyElement = 5,
    // _XmlWriterProperty_Last = 5, this enum value conflicts with XmlWriterProperty_CompactEmptyElement
};
pub const XmlWriterProperty_MultiLanguage = XmlWriterProperty.XmlWriterProperty_MultiLanguage;
pub const XmlWriterProperty_Indent = XmlWriterProperty.XmlWriterProperty_Indent;
pub const XmlWriterProperty_ByteOrderMark = XmlWriterProperty.XmlWriterProperty_ByteOrderMark;
pub const XmlWriterProperty_OmitXmlDeclaration = XmlWriterProperty.XmlWriterProperty_OmitXmlDeclaration;
pub const XmlWriterProperty_ConformanceLevel = XmlWriterProperty.XmlWriterProperty_ConformanceLevel;
pub const XmlWriterProperty_CompactEmptyElement = XmlWriterProperty.XmlWriterProperty_CompactEmptyElement;
pub const _XmlWriterProperty_Last = XmlWriterProperty.XmlWriterProperty_CompactEmptyElement;

const IID_IXmlReader_Value = Guid.initString("7279fc81-709d-4095-b63d-69fe4b0d9030");
pub const IID_IXmlReader = &IID_IXmlReader_Value;
pub const IXmlReader = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetInput: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                pInput: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                pInput: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                nProperty: u32,
                ppValue: ?*isize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                nProperty: u32,
                ppValue: ?*isize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                nProperty: u32,
                pValue: isize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                nProperty: u32,
                pValue: isize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Read: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                pNodeType: ?*XmlNodeType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                pNodeType: ?*XmlNodeType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetNodeType: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                pNodeType: ?*XmlNodeType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                pNodeType: ?*XmlNodeType,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MoveToFirstAttribute: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MoveToNextAttribute: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MoveToAttributeByName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                pwszLocalName: ?[*:0]const u16,
                pwszNamespaceUri: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                pwszLocalName: ?[*:0]const u16,
                pwszNamespaceUri: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        MoveToElement: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetQualifiedName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                ppwszQualifiedName: ?*?PWSTR,
                pcwchQualifiedName: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                ppwszQualifiedName: ?*?PWSTR,
                pcwchQualifiedName: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetNamespaceUri: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                ppwszNamespaceUri: ?*?PWSTR,
                pcwchNamespaceUri: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                ppwszNamespaceUri: ?*?PWSTR,
                pcwchNamespaceUri: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetLocalName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                ppwszLocalName: ?*?PWSTR,
                pcwchLocalName: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                ppwszLocalName: ?*?PWSTR,
                pcwchLocalName: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPrefix: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                ppwszPrefix: ?*?PWSTR,
                pcwchPrefix: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                ppwszPrefix: ?*?PWSTR,
                pcwchPrefix: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                ppwszValue: ?*?PWSTR,
                pcwchValue: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                ppwszValue: ?*?PWSTR,
                pcwchValue: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ReadValueChunk: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                pwchBuffer: [*:0]u16,
                cwchChunkSize: u32,
                pcwchRead: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                pwchBuffer: [*:0]u16,
                cwchChunkSize: u32,
                pcwchRead: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBaseUri: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                ppwszBaseUri: ?*?PWSTR,
                pcwchBaseUri: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                ppwszBaseUri: ?*?PWSTR,
                pcwchBaseUri: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsDefault: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
            else => *const fn (
                self: *const IXmlReader,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
        },
        IsEmptyElement: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
            else => *const fn (
                self: *const IXmlReader,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
        },
        GetLineNumber: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                pnLineNumber: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                pnLineNumber: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetLinePosition: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                pnLinePosition: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                pnLinePosition: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAttributeCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                pnAttributeCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                pnAttributeCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDepth: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
                pnDepth: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlReader,
                pnDepth: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsEOF: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlReader,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
            else => *const fn (
                self: *const IXmlReader,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_SetInput(self: *const T, pInput: ?*IUnknown) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).SetInput(@as(*const IXmlReader, @ptrCast(self)), pInput);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_GetProperty(self: *const T, nProperty: u32, ppValue: ?*isize) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).GetProperty(@as(*const IXmlReader, @ptrCast(self)), nProperty, ppValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_SetProperty(self: *const T, nProperty: u32, pValue: isize) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).SetProperty(@as(*const IXmlReader, @ptrCast(self)), nProperty, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_Read(self: *const T, pNodeType: ?*XmlNodeType) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).Read(@as(*const IXmlReader, @ptrCast(self)), pNodeType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_GetNodeType(self: *const T, pNodeType: ?*XmlNodeType) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).GetNodeType(@as(*const IXmlReader, @ptrCast(self)), pNodeType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_MoveToFirstAttribute(self: *const T) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).MoveToFirstAttribute(@as(*const IXmlReader, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_MoveToNextAttribute(self: *const T) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).MoveToNextAttribute(@as(*const IXmlReader, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_MoveToAttributeByName(self: *const T, pwszLocalName: ?[*:0]const u16, pwszNamespaceUri: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).MoveToAttributeByName(@as(*const IXmlReader, @ptrCast(self)), pwszLocalName, pwszNamespaceUri);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_MoveToElement(self: *const T) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).MoveToElement(@as(*const IXmlReader, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_GetQualifiedName(self: *const T, ppwszQualifiedName: ?*?PWSTR, pcwchQualifiedName: ?*u32) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).GetQualifiedName(@as(*const IXmlReader, @ptrCast(self)), ppwszQualifiedName, pcwchQualifiedName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_GetNamespaceUri(self: *const T, ppwszNamespaceUri: ?*?PWSTR, pcwchNamespaceUri: ?*u32) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).GetNamespaceUri(@as(*const IXmlReader, @ptrCast(self)), ppwszNamespaceUri, pcwchNamespaceUri);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_GetLocalName(self: *const T, ppwszLocalName: ?*?PWSTR, pcwchLocalName: ?*u32) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).GetLocalName(@as(*const IXmlReader, @ptrCast(self)), ppwszLocalName, pcwchLocalName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_GetPrefix(self: *const T, ppwszPrefix: ?*?PWSTR, pcwchPrefix: ?*u32) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).GetPrefix(@as(*const IXmlReader, @ptrCast(self)), ppwszPrefix, pcwchPrefix);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_GetValue(self: *const T, ppwszValue: ?*?PWSTR, pcwchValue: ?*u32) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).GetValue(@as(*const IXmlReader, @ptrCast(self)), ppwszValue, pcwchValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_ReadValueChunk(self: *const T, pwchBuffer: [*:0]u16, cwchChunkSize: u32, pcwchRead: ?*u32) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).ReadValueChunk(@as(*const IXmlReader, @ptrCast(self)), pwchBuffer, cwchChunkSize, pcwchRead);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_GetBaseUri(self: *const T, ppwszBaseUri: ?*?PWSTR, pcwchBaseUri: ?*u32) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).GetBaseUri(@as(*const IXmlReader, @ptrCast(self)), ppwszBaseUri, pcwchBaseUri);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_IsDefault(self: *const T) BOOL {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).IsDefault(@as(*const IXmlReader, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_IsEmptyElement(self: *const T) BOOL {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).IsEmptyElement(@as(*const IXmlReader, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_GetLineNumber(self: *const T, pnLineNumber: ?*u32) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).GetLineNumber(@as(*const IXmlReader, @ptrCast(self)), pnLineNumber);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_GetLinePosition(self: *const T, pnLinePosition: ?*u32) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).GetLinePosition(@as(*const IXmlReader, @ptrCast(self)), pnLinePosition);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_GetAttributeCount(self: *const T, pnAttributeCount: ?*u32) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).GetAttributeCount(@as(*const IXmlReader, @ptrCast(self)), pnAttributeCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_GetDepth(self: *const T, pnDepth: ?*u32) HRESULT {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).GetDepth(@as(*const IXmlReader, @ptrCast(self)), pnDepth);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlReader_IsEOF(self: *const T) BOOL {
                return @as(*const IXmlReader.VTable, @ptrCast(self.vtable)).IsEOF(@as(*const IXmlReader, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IXmlResolver_Value = Guid.initString("7279fc82-709d-4095-b63d-69fe4b0d9030");
pub const IID_IXmlResolver = &IID_IXmlResolver_Value;
pub const IXmlResolver = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        ResolveUri: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlResolver,
                pwszBaseUri: ?[*:0]const u16,
                pwszPublicIdentifier: ?[*:0]const u16,
                pwszSystemIdentifier: ?[*:0]const u16,
                ppResolvedInput: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlResolver,
                pwszBaseUri: ?[*:0]const u16,
                pwszPublicIdentifier: ?[*:0]const u16,
                pwszSystemIdentifier: ?[*:0]const u16,
                ppResolvedInput: ?*?*IUnknown,
            ) 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 IXmlResolver_ResolveUri(self: *const T, pwszBaseUri: ?[*:0]const u16, pwszPublicIdentifier: ?[*:0]const u16, pwszSystemIdentifier: ?[*:0]const u16, ppResolvedInput: ?*?*IUnknown) HRESULT {
                return @as(*const IXmlResolver.VTable, @ptrCast(self.vtable)).ResolveUri(@as(*const IXmlResolver, @ptrCast(self)), pwszBaseUri, pwszPublicIdentifier, pwszSystemIdentifier, ppResolvedInput);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IXmlWriter_Value = Guid.initString("7279fc88-709d-4095-b63d-69fe4b0d9030");
pub const IID_IXmlWriter = &IID_IXmlWriter_Value;
pub const IXmlWriter = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetOutput: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pOutput: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pOutput: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                nProperty: u32,
                ppValue: ?*isize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                nProperty: u32,
                ppValue: ?*isize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                nProperty: u32,
                pValue: isize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                nProperty: u32,
                pValue: isize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteAttributes: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pReader: ?*IXmlReader,
                fWriteDefaultAttributes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pReader: ?*IXmlReader,
                fWriteDefaultAttributes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteAttributeString: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszPrefix: ?[*:0]const u16,
                pwszLocalName: ?[*:0]const u16,
                pwszNamespaceUri: ?[*:0]const u16,
                pwszValue: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszPrefix: ?[*:0]const u16,
                pwszLocalName: ?[*:0]const u16,
                pwszNamespaceUri: ?[*:0]const u16,
                pwszValue: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteCData: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszText: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszText: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteCharEntity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                wch: u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                wch: u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteChars: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwch: ?[*:0]const u16,
                cwch: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwch: ?[*:0]const u16,
                cwch: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteComment: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszComment: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszComment: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteDocType: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszName: ?[*:0]const u16,
                pwszPublicId: ?[*:0]const u16,
                pwszSystemId: ?[*:0]const u16,
                pwszSubset: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszName: ?[*:0]const u16,
                pwszPublicId: ?[*:0]const u16,
                pwszSystemId: ?[*:0]const u16,
                pwszSubset: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteElementString: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszPrefix: ?[*:0]const u16,
                pwszLocalName: ?[*:0]const u16,
                pwszNamespaceUri: ?[*:0]const u16,
                pwszValue: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszPrefix: ?[*:0]const u16,
                pwszLocalName: ?[*:0]const u16,
                pwszNamespaceUri: ?[*:0]const u16,
                pwszValue: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteEndDocument: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteEndElement: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteEntityRef: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteFullEndElement: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteNmToken: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszNmToken: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszNmToken: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteNode: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pReader: ?*IXmlReader,
                fWriteDefaultAttributes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pReader: ?*IXmlReader,
                fWriteDefaultAttributes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteNodeShallow: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pReader: ?*IXmlReader,
                fWriteDefaultAttributes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pReader: ?*IXmlReader,
                fWriteDefaultAttributes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteProcessingInstruction: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszName: ?[*:0]const u16,
                pwszText: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszName: ?[*:0]const u16,
                pwszText: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteQualifiedName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszLocalName: ?[*:0]const u16,
                pwszNamespaceUri: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszLocalName: ?[*:0]const u16,
                pwszNamespaceUri: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteRaw: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszData: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszData: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteRawChars: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwch: ?[*:0]const u16,
                cwch: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwch: ?[*:0]const u16,
                cwch: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteStartDocument: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                standalone: XmlStandalone,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                standalone: XmlStandalone,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteStartElement: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszPrefix: ?[*:0]const u16,
                pwszLocalName: ?[*:0]const u16,
                pwszNamespaceUri: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszPrefix: ?[*:0]const u16,
                pwszLocalName: ?[*:0]const u16,
                pwszNamespaceUri: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteString: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszText: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszText: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteSurrogateCharEntity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                wchLow: u16,
                wchHigh: u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                wchLow: u16,
                wchHigh: u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteWhitespace: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
                pwszWhitespace: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
                pwszWhitespace: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Flush: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriter,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriter,
            ) 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 IXmlWriter_SetOutput(self: *const T, pOutput: ?*IUnknown) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).SetOutput(@as(*const IXmlWriter, @ptrCast(self)), pOutput);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_GetProperty(self: *const T, nProperty: u32, ppValue: ?*isize) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).GetProperty(@as(*const IXmlWriter, @ptrCast(self)), nProperty, ppValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_SetProperty(self: *const T, nProperty: u32, pValue: isize) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).SetProperty(@as(*const IXmlWriter, @ptrCast(self)), nProperty, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteAttributes(self: *const T, pReader: ?*IXmlReader, fWriteDefaultAttributes: BOOL) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteAttributes(@as(*const IXmlWriter, @ptrCast(self)), pReader, fWriteDefaultAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteAttributeString(self: *const T, pwszPrefix: ?[*:0]const u16, pwszLocalName: ?[*:0]const u16, pwszNamespaceUri: ?[*:0]const u16, pwszValue: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteAttributeString(@as(*const IXmlWriter, @ptrCast(self)), pwszPrefix, pwszLocalName, pwszNamespaceUri, pwszValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteCData(self: *const T, pwszText: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteCData(@as(*const IXmlWriter, @ptrCast(self)), pwszText);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteCharEntity(self: *const T, wch: u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteCharEntity(@as(*const IXmlWriter, @ptrCast(self)), wch);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteChars(self: *const T, pwch: ?[*:0]const u16, cwch: u32) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteChars(@as(*const IXmlWriter, @ptrCast(self)), pwch, cwch);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteComment(self: *const T, pwszComment: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteComment(@as(*const IXmlWriter, @ptrCast(self)), pwszComment);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteDocType(self: *const T, pwszName: ?[*:0]const u16, pwszPublicId: ?[*:0]const u16, pwszSystemId: ?[*:0]const u16, pwszSubset: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteDocType(@as(*const IXmlWriter, @ptrCast(self)), pwszName, pwszPublicId, pwszSystemId, pwszSubset);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteElementString(self: *const T, pwszPrefix: ?[*:0]const u16, pwszLocalName: ?[*:0]const u16, pwszNamespaceUri: ?[*:0]const u16, pwszValue: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteElementString(@as(*const IXmlWriter, @ptrCast(self)), pwszPrefix, pwszLocalName, pwszNamespaceUri, pwszValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteEndDocument(self: *const T) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteEndDocument(@as(*const IXmlWriter, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteEndElement(self: *const T) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteEndElement(@as(*const IXmlWriter, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteEntityRef(self: *const T, pwszName: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteEntityRef(@as(*const IXmlWriter, @ptrCast(self)), pwszName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteFullEndElement(self: *const T) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteFullEndElement(@as(*const IXmlWriter, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteName(self: *const T, pwszName: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteName(@as(*const IXmlWriter, @ptrCast(self)), pwszName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteNmToken(self: *const T, pwszNmToken: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteNmToken(@as(*const IXmlWriter, @ptrCast(self)), pwszNmToken);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteNode(self: *const T, pReader: ?*IXmlReader, fWriteDefaultAttributes: BOOL) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteNode(@as(*const IXmlWriter, @ptrCast(self)), pReader, fWriteDefaultAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteNodeShallow(self: *const T, pReader: ?*IXmlReader, fWriteDefaultAttributes: BOOL) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteNodeShallow(@as(*const IXmlWriter, @ptrCast(self)), pReader, fWriteDefaultAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteProcessingInstruction(self: *const T, pwszName: ?[*:0]const u16, pwszText: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteProcessingInstruction(@as(*const IXmlWriter, @ptrCast(self)), pwszName, pwszText);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteQualifiedName(self: *const T, pwszLocalName: ?[*:0]const u16, pwszNamespaceUri: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteQualifiedName(@as(*const IXmlWriter, @ptrCast(self)), pwszLocalName, pwszNamespaceUri);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteRaw(self: *const T, pwszData: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteRaw(@as(*const IXmlWriter, @ptrCast(self)), pwszData);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteRawChars(self: *const T, pwch: ?[*:0]const u16, cwch: u32) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteRawChars(@as(*const IXmlWriter, @ptrCast(self)), pwch, cwch);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteStartDocument(self: *const T, standalone: XmlStandalone) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteStartDocument(@as(*const IXmlWriter, @ptrCast(self)), standalone);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteStartElement(self: *const T, pwszPrefix: ?[*:0]const u16, pwszLocalName: ?[*:0]const u16, pwszNamespaceUri: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteStartElement(@as(*const IXmlWriter, @ptrCast(self)), pwszPrefix, pwszLocalName, pwszNamespaceUri);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteString(self: *const T, pwszText: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteString(@as(*const IXmlWriter, @ptrCast(self)), pwszText);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteSurrogateCharEntity(self: *const T, wchLow: u16, wchHigh: u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteSurrogateCharEntity(@as(*const IXmlWriter, @ptrCast(self)), wchLow, wchHigh);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_WriteWhitespace(self: *const T, pwszWhitespace: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).WriteWhitespace(@as(*const IXmlWriter, @ptrCast(self)), pwszWhitespace);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriter_Flush(self: *const T) HRESULT {
                return @as(*const IXmlWriter.VTable, @ptrCast(self.vtable)).Flush(@as(*const IXmlWriter, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IXmlWriterLite_Value = Guid.initString("862494c6-1310-4aad-b3cd-2dbeebf670d3");
pub const IID_IXmlWriterLite = &IID_IXmlWriterLite_Value;
pub const IXmlWriterLite = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetOutput: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pOutput: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pOutput: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                nProperty: u32,
                ppValue: ?*isize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                nProperty: u32,
                ppValue: ?*isize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                nProperty: u32,
                pValue: isize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                nProperty: u32,
                pValue: isize,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteAttributes: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pReader: ?*IXmlReader,
                fWriteDefaultAttributes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pReader: ?*IXmlReader,
                fWriteDefaultAttributes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteAttributeString: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszQName: [*:0]const u16,
                cwszQName: u32,
                pwszValue: ?[*:0]const u16,
                cwszValue: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszQName: [*:0]const u16,
                cwszQName: u32,
                pwszValue: ?[*:0]const u16,
                cwszValue: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteCData: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszText: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszText: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteCharEntity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                wch: u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                wch: u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteChars: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwch: ?[*:0]const u16,
                cwch: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwch: ?[*:0]const u16,
                cwch: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteComment: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszComment: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszComment: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteDocType: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszName: ?[*:0]const u16,
                pwszPublicId: ?[*:0]const u16,
                pwszSystemId: ?[*:0]const u16,
                pwszSubset: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszName: ?[*:0]const u16,
                pwszPublicId: ?[*:0]const u16,
                pwszSystemId: ?[*:0]const u16,
                pwszSubset: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteElementString: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszQName: [*:0]const u16,
                cwszQName: u32,
                pwszValue: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszQName: [*:0]const u16,
                cwszQName: u32,
                pwszValue: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteEndDocument: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteEndElement: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszQName: [*:0]const u16,
                cwszQName: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszQName: [*:0]const u16,
                cwszQName: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteEntityRef: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteFullEndElement: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszQName: [*:0]const u16,
                cwszQName: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszQName: [*:0]const u16,
                cwszQName: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszName: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteNmToken: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszNmToken: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszNmToken: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteNode: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pReader: ?*IXmlReader,
                fWriteDefaultAttributes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pReader: ?*IXmlReader,
                fWriteDefaultAttributes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteNodeShallow: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pReader: ?*IXmlReader,
                fWriteDefaultAttributes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pReader: ?*IXmlReader,
                fWriteDefaultAttributes: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteProcessingInstruction: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszName: ?[*:0]const u16,
                pwszText: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszName: ?[*:0]const u16,
                pwszText: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteRaw: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszData: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszData: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteRawChars: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwch: ?[*:0]const u16,
                cwch: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwch: ?[*:0]const u16,
                cwch: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteStartDocument: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                standalone: XmlStandalone,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                standalone: XmlStandalone,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteStartElement: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszQName: [*:0]const u16,
                cwszQName: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszQName: [*:0]const u16,
                cwszQName: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteString: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszText: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszText: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteSurrogateCharEntity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                wchLow: u16,
                wchHigh: u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                wchLow: u16,
                wchHigh: u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteWhitespace: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
                pwszWhitespace: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
                pwszWhitespace: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Flush: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IXmlWriterLite,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IXmlWriterLite,
            ) 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 IXmlWriterLite_SetOutput(self: *const T, pOutput: ?*IUnknown) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).SetOutput(@as(*const IXmlWriterLite, @ptrCast(self)), pOutput);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_GetProperty(self: *const T, nProperty: u32, ppValue: ?*isize) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).GetProperty(@as(*const IXmlWriterLite, @ptrCast(self)), nProperty, ppValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_SetProperty(self: *const T, nProperty: u32, pValue: isize) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).SetProperty(@as(*const IXmlWriterLite, @ptrCast(self)), nProperty, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteAttributes(self: *const T, pReader: ?*IXmlReader, fWriteDefaultAttributes: BOOL) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteAttributes(@as(*const IXmlWriterLite, @ptrCast(self)), pReader, fWriteDefaultAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteAttributeString(self: *const T, pwszQName: [*:0]const u16, cwszQName: u32, pwszValue: ?[*:0]const u16, cwszValue: u32) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteAttributeString(@as(*const IXmlWriterLite, @ptrCast(self)), pwszQName, cwszQName, pwszValue, cwszValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteCData(self: *const T, pwszText: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteCData(@as(*const IXmlWriterLite, @ptrCast(self)), pwszText);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteCharEntity(self: *const T, wch: u16) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteCharEntity(@as(*const IXmlWriterLite, @ptrCast(self)), wch);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteChars(self: *const T, pwch: ?[*:0]const u16, cwch: u32) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteChars(@as(*const IXmlWriterLite, @ptrCast(self)), pwch, cwch);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteComment(self: *const T, pwszComment: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteComment(@as(*const IXmlWriterLite, @ptrCast(self)), pwszComment);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteDocType(self: *const T, pwszName: ?[*:0]const u16, pwszPublicId: ?[*:0]const u16, pwszSystemId: ?[*:0]const u16, pwszSubset: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteDocType(@as(*const IXmlWriterLite, @ptrCast(self)), pwszName, pwszPublicId, pwszSystemId, pwszSubset);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteElementString(self: *const T, pwszQName: [*:0]const u16, cwszQName: u32, pwszValue: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteElementString(@as(*const IXmlWriterLite, @ptrCast(self)), pwszQName, cwszQName, pwszValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteEndDocument(self: *const T) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteEndDocument(@as(*const IXmlWriterLite, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteEndElement(self: *const T, pwszQName: [*:0]const u16, cwszQName: u32) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteEndElement(@as(*const IXmlWriterLite, @ptrCast(self)), pwszQName, cwszQName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteEntityRef(self: *const T, pwszName: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteEntityRef(@as(*const IXmlWriterLite, @ptrCast(self)), pwszName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteFullEndElement(self: *const T, pwszQName: [*:0]const u16, cwszQName: u32) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteFullEndElement(@as(*const IXmlWriterLite, @ptrCast(self)), pwszQName, cwszQName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteName(self: *const T, pwszName: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteName(@as(*const IXmlWriterLite, @ptrCast(self)), pwszName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteNmToken(self: *const T, pwszNmToken: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteNmToken(@as(*const IXmlWriterLite, @ptrCast(self)), pwszNmToken);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteNode(self: *const T, pReader: ?*IXmlReader, fWriteDefaultAttributes: BOOL) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteNode(@as(*const IXmlWriterLite, @ptrCast(self)), pReader, fWriteDefaultAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteNodeShallow(self: *const T, pReader: ?*IXmlReader, fWriteDefaultAttributes: BOOL) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteNodeShallow(@as(*const IXmlWriterLite, @ptrCast(self)), pReader, fWriteDefaultAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteProcessingInstruction(self: *const T, pwszName: ?[*:0]const u16, pwszText: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteProcessingInstruction(@as(*const IXmlWriterLite, @ptrCast(self)), pwszName, pwszText);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteRaw(self: *const T, pwszData: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteRaw(@as(*const IXmlWriterLite, @ptrCast(self)), pwszData);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteRawChars(self: *const T, pwch: ?[*:0]const u16, cwch: u32) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteRawChars(@as(*const IXmlWriterLite, @ptrCast(self)), pwch, cwch);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteStartDocument(self: *const T, standalone: XmlStandalone) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteStartDocument(@as(*const IXmlWriterLite, @ptrCast(self)), standalone);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteStartElement(self: *const T, pwszQName: [*:0]const u16, cwszQName: u32) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteStartElement(@as(*const IXmlWriterLite, @ptrCast(self)), pwszQName, cwszQName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteString(self: *const T, pwszText: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteString(@as(*const IXmlWriterLite, @ptrCast(self)), pwszText);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteSurrogateCharEntity(self: *const T, wchLow: u16, wchHigh: u16) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteSurrogateCharEntity(@as(*const IXmlWriterLite, @ptrCast(self)), wchLow, wchHigh);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_WriteWhitespace(self: *const T, pwszWhitespace: ?[*:0]const u16) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).WriteWhitespace(@as(*const IXmlWriterLite, @ptrCast(self)), pwszWhitespace);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IXmlWriterLite_Flush(self: *const T) HRESULT {
                return @as(*const IXmlWriterLite.VTable, @ptrCast(self.vtable)).Flush(@as(*const IXmlWriterLite, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

//--------------------------------------------------------------------------------
// Section: Functions (6)
//--------------------------------------------------------------------------------
pub extern "xmllite" fn CreateXmlReader(
    riid: ?*const Guid,
    ppvObject: ?*?*anyopaque,
    pMalloc: ?*IMalloc,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "xmllite" fn CreateXmlReaderInputWithEncodingCodePage(
    pInputStream: ?*IUnknown,
    pMalloc: ?*IMalloc,
    nEncodingCodePage: u32,
    fEncodingHint: BOOL,
    pwszBaseUri: ?[*:0]const u16,
    ppInput: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "xmllite" fn CreateXmlReaderInputWithEncodingName(
    pInputStream: ?*IUnknown,
    pMalloc: ?*IMalloc,
    pwszEncodingName: ?[*:0]const u16,
    fEncodingHint: BOOL,
    pwszBaseUri: ?[*:0]const u16,
    ppInput: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "xmllite" fn CreateXmlWriter(
    riid: ?*const Guid,
    ppvObject: ?*?*anyopaque,
    pMalloc: ?*IMalloc,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "xmllite" fn CreateXmlWriterOutputWithEncodingCodePage(
    pOutputStream: ?*IUnknown,
    pMalloc: ?*IMalloc,
    nEncodingCodePage: u32,
    ppOutput: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "xmllite" fn CreateXmlWriterOutputWithEncodingName(
    pOutputStream: ?*IUnknown,
    pMalloc: ?*IMalloc,
    pwszEncodingName: ?[*:0]const u16,
    ppOutput: ?*?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../../zig.zig").unicode_mode) {
    .ansi => struct {},
    .wide => struct {},
    .unspecified => if (@import("builtin").is_test) struct {} else struct {},
};
//--------------------------------------------------------------------------------
// Section: Imports (6)
//--------------------------------------------------------------------------------
const Guid = @import("../../zig.zig").Guid;
const BOOL = @import("../../foundation.zig").BOOL;
const HRESULT = @import("../../foundation.zig").HRESULT;
const IMalloc = @import("../../system/com.zig").IMalloc;
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);
        }
    }
}
