//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (c) Microsoft Corporation. All rights reserved.
//
//  File: msxml2.idl
//
//--------------------------------------------------------------------------

cpp_quote("//+-------------------------------------------------------------------------")
cpp_quote("//")
cpp_quote("//  Microsoft Windows")
cpp_quote("//  Copyright (C) Microsoft Corporation, 1997-2006.")
cpp_quote("//")
cpp_quote("//--------------------------------------------------------------------------")

cpp_quote("#include <winapifamily.h>")

#pragma region Desktop Family
cpp_quote("#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)")

#include "msxml2did.h"
#include <idispids.h>

#ifndef DO_NO_IMPORTS
import "unknwn.idl";
import "wtypes.idl";
import "objidl.idl";
import "oaidl.idl";
#endif

// DOMDocument has a different guid in IE5.
// In msxml3 and above it is a version independent guid.
// To avoid compile errors define it to be DOMDocument2

cpp_quote("#define DOMDocument DOMDocument2")
cpp_quote("#define CLSID_DOMDocument CLSID_DOMDocument2")
cpp_quote("")
cpp_quote("#ifdef __USE_MSXML2_NAMESPACE__")
cpp_quote("namespace MSXML2 {")
cpp_quote("#endif")

cpp_quote("#ifndef __msxml_h__")

#ifndef IMPORTED_MSXML
typedef struct _xml_error {
    unsigned        _nLine;         // line number
    BSTR            _pchBuf;        // current input buffer
    unsigned        _cchBuf;        // number of chars in buffer
    unsigned        _ich;           // index of the char when error occurred
    BSTR            _pszFound;      // token found
    BSTR            _pszExpected;   // token expected
    DWORD           _reserved1;     // reserved
    DWORD           _reserved2;     // reserved
} XML_ERROR;
// If, when importing this file into another idl file you receive duplicate definition
// errors, define IMPORTED_MSXML on the command line to the MIDL compiler.
#endif
cpp_quote("#endif")

cpp_quote("#ifdef __ISAXXMLReader_INTERFACE_DEFINED__")
cpp_quote("#undef __MSXML2_LIBRARY_DEFINED__")
cpp_quote("#endif")

[
    uuid(f5078f18-c551-11d3-89b9-0000f81fe221),
    version(3.0),
    helpstring("Microsoft XML, v3.0"),
    lcid(0x0000)
]

library MSXML2
{

importlib("stdole32.tlb");
importlib("stdole2.tlb");

// XMLDOM
interface IXMLDOMImplementation;
interface IXMLDOMNode;
interface IXMLDOMDocumentFragment;
interface IXMLDOMDocument;
interface IXMLDOMDocument2;
interface IXMLDOMDocument3;
interface IXMLDOMNodeList;
interface IXMLDOMNamedNodeMap;
interface IXMLDOMCharacterData;
interface IXMLDOMAttribute;
interface IXMLDOMElement;
interface IXMLDOMText;
interface IXMLDOMComment;
interface IXMLDOMProcessingInstruction;
interface IXMLDOMCDATASection;
interface IXMLDOMDocumentType;
interface IXMLDOMNotation;
interface IXMLDOMEntity;
interface IXMLDOMEntityReference;
interface IXMLDOMParseError;
interface IXMLDOMParseError2;
interface IXMLDOMParseErrorCollection;
interface IXMLDOMSchemaCollection;
interface IXTLRuntime;
interface IXSLTemplate;
interface IXSLProcessor;

// SAX
interface ISAXXMLReader;
interface ISAXXMLFilter;
interface ISAXLocator;
interface ISAXEntityResolver;
interface ISAXContentHandler;
interface ISAXDTDHandler;
interface ISAXErrorHandler;
interface ISAXLexicalHandler;
interface ISAXDeclHandler;
interface ISAXAttributes;

interface IVBSAXXMLReader;
interface IVBSAXXMLFilter;
interface IVBSAXLocator;
interface IVBSAXEntityResolver;
interface IVBSAXContentHandler;
interface IVBSAXDTDHandler;
interface IVBSAXErrorHandler;
interface IVBSAXLexicalHandler;
interface IVBSAXDeclHandler;
interface IVBSAXAttributes;

interface IMXWriter;
interface IMXAttributes;
interface IMXReaderControl;
interface IMXSchemaDeclHandler;
interface IMXXMLFilter;

// SOM
interface IXMLDOMSchemaCollection2;
interface ISchemaStringCollection;
interface ISchemaItemCollection;
interface ISchemaItem;
interface ISchema;
interface ISchemaParticle;
interface ISchemaAttribute;
interface ISchemaElement;
interface ISchemaType;
interface ISchemaComplexType;
interface ISchemaAttributeGroup;
interface ISchemaModelGroup;
interface ISchemaAny;
interface ISchemaIdentityConstraint;
interface ISchemaNotation;

// IE4 ObjectModel
interface IXMLElementCollection;
interface IXMLDocument;
interface IXMLDocument2;
interface IXMLElement;
interface IXMLElement2;
interface IXMLAttribute;
interface IXMLError;
interface IXMLElementNotificationSink;


/// This is needed to avoid having the (SAX) ParseURL method 
/// become the ParseURLA method.
cpp_quote("#undef ParseURL")


cpp_quote("#if !defined(__msxml_h__)")
#ifndef IMPORTED_MSXML
typedef [
helpstring("Constants that define types for IXMLElement.")
] enum tagXMLEMEM_TYPE
{
    XMLELEMTYPE_ELEMENT,
    XMLELEMTYPE_TEXT,
    XMLELEMTYPE_COMMENT,
    XMLELEMTYPE_DOCUMENT,
    XMLELEMTYPE_DTD,
    XMLELEMTYPE_PI,
    XMLELEMTYPE_OTHER
} XMLELEM_TYPE;
#endif
cpp_quote("#endif")

// IE4 msxml.h also defines __msxml_h__.  The only way to tell the difference between IE4 msxml.h and IE5 msxml.h is the
// via the obsolete interface __IXMLElementNotificationSink_INTERFACE_DEFINED__ defined by IE4
cpp_quote("#if !defined(__msxml_h__) || defined(__IXMLElementNotificationSink_INTERFACE_DEFINED__)")

typedef [
helpstring("Constants that define a node's type")
] enum tagDOMNodeType 
{  
    NODE_INVALID, // = 0
    NODE_ELEMENT, // = 1
    NODE_ATTRIBUTE, // = 2
    NODE_TEXT, // = 3
    NODE_CDATA_SECTION, // = 4
    NODE_ENTITY_REFERENCE, // = 5
    NODE_ENTITY, // = 6
    NODE_PROCESSING_INSTRUCTION, // = 7
    NODE_COMMENT, // = 8
    NODE_DOCUMENT, // = 9
    NODE_DOCUMENT_TYPE, // = 10
    NODE_DOCUMENT_FRAGMENT, // = 11
    NODE_NOTATION // = 12
} DOMNodeType; 

cpp_quote("#endif")

[
    local, object,
    uuid(2933BF80-7B36-11d2-B20E-00C04F983E60), // IID_INode
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("Core DOM node interface"),
    pointer_default(unique)
]
interface IXMLDOMNode : IDispatch
{
    // readonly attribute  wstring              nodeName;
    [propget, id(DISPID_DOM_NODE_NODENAME), 
     helpstring("name of the node")]
    HRESULT nodeName(
        [out, retval] BSTR * name);

    //          attribute  wstring              nodeValue;
    [propget, id(DISPID_DOM_NODE_NODEVALUE), 
     helpstring("value stored in the node")]
    HRESULT nodeValue(
        [out, retval] VARIANT * value);

    [propput, id(DISPID_DOM_NODE_NODEVALUE), 
     helpstring("value stored in the node")]
    HRESULT nodeValue(
        [in] VARIANT value);

    // readonly attribute  unsigned short       nodeType;
    [propget, id(DISPID_DOM_NODE_NODETYPE), 
     helpstring("the node's type")]
    HRESULT nodeType(
        [out, retval] DOMNodeType * type);

    // readonly attribute  Node                 parentNode;
    [propget, id(DISPID_DOM_NODE_PARENTNODE), 
     helpstring("parent of the node")]
    HRESULT parentNode(
        [out, retval] IXMLDOMNode ** parent);

    // readonly attribute  NodeList             childNodes;
    [propget, id(DISPID_DOM_NODE_CHILDNODES), 
     helpstring("the collection of the node's children")]
    HRESULT childNodes(
        [out, retval] IXMLDOMNodeList ** childList);

    // readonly attribute  Node                 firstChild;
    [propget,id(DISPID_DOM_NODE_FIRSTCHILD),
     helpstring("first child of the node")]
    HRESULT firstChild(
        [out, retval] IXMLDOMNode ** firstChild);

    // readonly attribute  Node                 lastChild;
    [propget,id(DISPID_DOM_NODE_LASTCHILD),
     helpstring("last child of the node")]
    HRESULT lastChild(
        [out, retval] IXMLDOMNode ** lastChild);

    // readonly attribute  Node                 previousSibling;
    [propget,id(DISPID_DOM_NODE_PREVIOUSSIBLING),
     helpstring("left sibling of the node")]
    HRESULT previousSibling(
        [out, retval] IXMLDOMNode ** previousSibling);

    // readonly attribute  Node                 nextSibling;
    [propget,id(DISPID_DOM_NODE_NEXTSIBLING),
     helpstring("right sibling of the node")]
    HRESULT nextSibling(
        [out, retval] IXMLDOMNode ** nextSibling);

    // readonly attribute  NamedNodeMap         attributes;
    [propget, id(DISPID_DOM_NODE_ATTRIBUTES), 
     helpstring("the collection of the node's attributes")]
    HRESULT attributes(
        [out, retval] IXMLDOMNamedNodeMap ** attributeMap);


    // Node                      insertBefore(in Node newChild, 
    //                                        in Node refChild)
    //                                        raises(DOMException);
    [id(DISPID_DOM_NODE_INSERTBEFORE),
     helpstring("insert a child node")]
    HRESULT insertBefore(
        [in] IXMLDOMNode * newChild,
        [in] VARIANT refChild,
        [out, retval] IXMLDOMNode ** outNewChild);

    // Node                      replaceChild(in Node newChild, 
    //                                        in Node oldChild)
    //                                        raises(DOMException);
    [id(DISPID_DOM_NODE_REPLACECHILD),
     helpstring("replace a child node")]
    HRESULT replaceChild(
        [in] IXMLDOMNode * newChild,
        [in] IXMLDOMNode * oldChild,
        [out, retval] IXMLDOMNode ** outOldChild);
  
    // Node                      removeChild(in Node childNode)
    //                                       raises(DOMException);
    [id(DISPID_DOM_NODE_REMOVECHILD),
     helpstring("remove a child node")]
    HRESULT removeChild(
        [in] IXMLDOMNode * childNode,
        [out, retval] IXMLDOMNode ** oldChild);

    // Node                      appendChild(in Node newChild);
    [id(DISPID_DOM_NODE_APPENDCHILD),
     helpstring("append a child node")]
    HRESULT appendChild(
        [in] IXMLDOMNode * newChild,
        [out, retval] IXMLDOMNode ** outNewChild);

    // boolean                   hasChildNodes();
    [id(DISPID_DOM_NODE_HASCHILDNODES),
     helpstring("")]
    HRESULT hasChildNodes(
        [out, retval] VARIANT_BOOL * hasChild);

    // readonly attribute  Node                 ownerDocument;
    [propget, id(DISPID_DOM_NODE_OWNERDOC), 
     helpstring("document that contains the node")]
    HRESULT ownerDocument(
        [out, retval] IXMLDOMDocument ** XMLDOMDocument);

    // Node                      cloneNode(in boolean deep);
    [id(DISPID_DOM_NODE_CLONENODE),
     helpstring("")]
    HRESULT cloneNode(
        [in] VARIANT_BOOL deep,
        [out, retval] IXMLDOMNode ** cloneRoot);

    [propget, id(DISPID_XMLDOM_NODE_STRINGTYPE),
     helpstring("the type of node in string form")] 
    HRESULT nodeTypeString(
        [retval, out] BSTR * nodeType);

    [propget, id(DISPID_XMLDOM_NODE_TEXT),
     helpstring("text content of the node and subtree")] 
    HRESULT text(
        [retval, out] BSTR * text);

    [propput, id(DISPID_XMLDOM_NODE_TEXT),
     helpstring("text content of the node and subtree")] 
    HRESULT text(
        [in] BSTR text);

    [propget, id(DISPID_XMLDOM_NODE_SPECIFIED),
     helpstring("indicates whether node is a default value")]
    HRESULT specified(
        [out, retval] VARIANT_BOOL * isSpecified);

    // DTD Navigation.
    [propget, id(DISPID_XMLDOM_NODE_DEFINITION), 
     helpstring("pointer to the definition of the node in the DTD or schema")] 
    HRESULT definition(
        [retval,out] IXMLDOMNode ** definitionNode);

    [propget, id(DISPID_XMLDOM_NODE_NODETYPEDVALUE), 
     helpstring("get the strongly typed value of the node")] 
    HRESULT nodeTypedValue(
        [retval, out] VARIANT * typedValue);

    [propput, id(DISPID_XMLDOM_NODE_NODETYPEDVALUE), 
     helpstring("get the strongly typed value of the node")] 
    HRESULT nodeTypedValue(
        [in] VARIANT typedValue);

    [propget, id(DISPID_XMLDOM_NODE_DATATYPE), 
     helpstring("the data type of the node")] 
    HRESULT dataType(
        [retval, out] VARIANT * dataTypeName); // BSTR or VT_NULL

    [propput, id(DISPID_XMLDOM_NODE_DATATYPE), 
     helpstring("the data type of the node")] 
    HRESULT dataType(
        [in] BSTR dataTypeName);

    [propget, id(DISPID_XMLDOM_NODE_XML), 
     helpstring("return the XML source for the node and each of its descendants")] 
    HRESULT xml(
        [retval, out] BSTR * xmlString);

    [id(DISPID_XMLDOM_NODE_TRANSFORMNODE), 
     helpstring("apply the stylesheet to the subtree")] 
    HRESULT transformNode(
        [in] IXMLDOMNode * stylesheet,
        [retval, out] BSTR * xmlString);

    [id(DISPID_XMLDOM_NODE_SELECTNODES), 
     helpstring("execute query on the subtree")]
    HRESULT selectNodes(
        [in] BSTR queryString,
        [retval, out] IXMLDOMNodeList** resultList);

    [id(DISPID_XMLDOM_NODE_SELECTSINGLENODE), 
     helpstring("execute query on the subtree")]
    HRESULT selectSingleNode(
        [in] BSTR queryString,
        [retval, out] IXMLDOMNode** resultNode);

    [propget,id(DISPID_XMLDOM_NODE_PARSED), 
     helpstring("has sub-tree been completely parsed")]
    HRESULT parsed(
        [retval, out] VARIANT_BOOL * isParsed);

    [propget, id(DISPID_XMLDOM_NODE_NAMESPACE), 
     helpstring("the URI for the namespace applying to the node")] 
    HRESULT namespaceURI(
        [retval, out] BSTR * namespaceURI);

    [propget, id(DISPID_XMLDOM_NODE_PREFIX), 
     helpstring("the prefix for the namespace applying to the node")] 
    HRESULT prefix(
        [retval, out] BSTR * prefixString);

    [propget, id(DISPID_XMLDOM_NODE_BASENAME), 
     helpstring("the base name of the node (nodename with the prefix stripped off)")] 
    HRESULT baseName(
        [retval, out] BSTR * nameString);

    [id(DISPID_XMLDOM_NODE_TRANSFORMNODETOOBJECT), 
     helpstring("apply the stylesheet to the subtree, returning the result through a document or a stream")] 
    HRESULT transformNodeToObject(
        [in] IXMLDOMNode * stylesheet,
        [in] VARIANT outputObject);

};

[
    local, object,
    uuid(2933BF81-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMDocument
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique),
    hidden
]
interface IXMLDOMDocument : IXMLDOMNode 
{
    // readonly attribute  DocumentType         doctype;
    [propget, id(DISPID_DOM_DOCUMENT_DOCTYPE),
     helpstring("node corresponding to the DOCTYPE")]
    HRESULT doctype(
        [out, retval] IXMLDOMDocumentType ** documentType); 

    // readonly attribute  DOMImplementation    implementation;
    [propget, id(DISPID_DOM_DOCUMENT_IMPLEMENTATION),
     helpstring("info on this DOM implementation")]
    HRESULT implementation(
        [out, retval] IXMLDOMImplementation ** impl);

    // attribute  Element              documentElement;
    [propget, id(DISPID_DOM_DOCUMENT_DOCUMENTELEMENT),
     helpstring("the root of the tree")]
    HRESULT documentElement(
        [out, retval] IXMLDOMElement ** DOMElement);

    [propputref, id(DISPID_DOM_DOCUMENT_DOCUMENTELEMENT),
     helpstring("the root of the tree")]
    HRESULT documentElement(
        [in] IXMLDOMElement * DOMElement);

    // Element                   createElement(in wstring tagName);
    [id(DISPID_DOM_DOCUMENT_CREATEELEMENT),
     helpstring("create an Element node")]
    HRESULT createElement(
        [in] BSTR tagName,
        [out, retval] IXMLDOMElement ** element);

    // DocumentFragment          createDocumentFragment();
    [id(DISPID_DOM_DOCUMENT_CREATEDOCUMENTFRAGMENT),
     helpstring("create a DocumentFragment node")]
    HRESULT createDocumentFragment(
        [out, retval] IXMLDOMDocumentFragment ** docFrag );

    // Text                      createTextNode(in wstring data);
    [id(DISPID_DOM_DOCUMENT_CREATETEXTNODE),
     helpstring("create a text node")]
    HRESULT createTextNode(
        [in] BSTR data,
        [out, retval] IXMLDOMText ** text);

    // Comment                   createComment(in wstring data);
    [id(DISPID_DOM_DOCUMENT_CREATECOMMENT),
     helpstring("create a comment node")]
    HRESULT createComment(
        [in] BSTR data,
        [out, retval] IXMLDOMComment ** comment);

    // CDATASection              createCDATASection(in wstring data);
    [id(DISPID_DOM_DOCUMENT_CREATECDATASECTION),
     helpstring("create a CDATA section node")]
    HRESULT createCDATASection(
        [in] BSTR data,
        [out, retval] IXMLDOMCDATASection ** cdata);

    // ProcessingInstruction     createProcessingInstruction(in wstring target, 
    //                                                       in wstring data);
    [id(DISPID_DOM_DOCUMENT_CREATEPROCESSINGINSTRUCTION),
     helpstring("create a processing instruction node")]
    HRESULT createProcessingInstruction(
        [in] BSTR target,
        [in] BSTR data,
        [out, retval] IXMLDOMProcessingInstruction ** pi);

    // Attribute                 createAttribute(in wstring name);
    [id(DISPID_DOM_DOCUMENT_CREATEATTRIBUTE),
     helpstring("create an attribute node")]
    HRESULT createAttribute(
        [in] BSTR name,
        [out, retval] IXMLDOMAttribute ** attribute);

    // EntityReference           createEntityReference(in wstring name);
    [id(DISPID_DOM_DOCUMENT_CREATEENTITYREFERENCE),
     helpstring("create an entity reference node")]
    HRESULT createEntityReference(
        [in] BSTR name,
        [out, retval] IXMLDOMEntityReference ** entityRef);

    // NodeList                  getElementsByTagName(in wstring tagname);
    [id(DISPID_DOM_DOCUMENT_GETELEMENTSBYTAGNAME),
     helpstring("build a list of elements by name")]
    HRESULT getElementsByTagName(
        [in] BSTR tagName,
        [out, retval] IXMLDOMNodeList ** resultList);

    [id(DISPID_XMLDOM_DOCUMENT_CREATENODE), 
     helpstring("create a node of the specified node type and name")] 
    HRESULT createNode(
        [in] VARIANT Type, 
        [in] BSTR name, 
        [in] BSTR namespaceURI,
        [retval, out] IXMLDOMNode ** node);

    [id(DISPID_XMLDOM_DOCUMENT_NODEFROMID), 
     helpstring("retrieve node from it's ID")]
    HRESULT nodeFromID( 
        [in] BSTR idString,
        [retval, out] IXMLDOMNode ** node);

    [id(DISPID_XMLDOM_DOCUMENT_LOAD), 
     helpstring("load document from the specified XML source")] 
    HRESULT load(
        [in] VARIANT xmlSource,
        [out, retval] VARIANT_BOOL * isSuccessful);

    [propget, id(DISPID_READYSTATE), 
     helpstring("get the state of the XML document")] 
    HRESULT readyState(
        [retval, out] long * value);

    [propget, id(DISPID_XMLDOM_DOCUMENT_PARSEERROR), 
     helpstring("get the last parser error")] 
    HRESULT parseError(
        [retval, out] IXMLDOMParseError ** errorObj);

    [propget, id(DISPID_XMLDOM_DOCUMENT_URL), 
     helpstring("get the URL for the loaded XML document")] 
    HRESULT url(
        [retval, out] BSTR * urlString);

    [propget, id(DISPID_XMLDOM_DOCUMENT_ASYNC), 
     helpstring("flag for asynchronous download")] 
    HRESULT async(
        [retval, out] VARIANT_BOOL * isAsync);

    [propput, id(DISPID_XMLDOM_DOCUMENT_ASYNC), 
     helpstring("flag for asynchronous download")] 
    HRESULT async(
        [in] VARIANT_BOOL isAsync);

    [id(DISPID_XMLDOM_DOCUMENT_ABORT), 
     helpstring("abort an asynchronous download")] 
    HRESULT abort();

    [id(DISPID_XMLDOM_DOCUMENT_LOADXML), 
     helpstring("load the document from a string")] 
    HRESULT loadXML( 
        [in] BSTR bstrXML,
        [out, retval] VARIANT_BOOL * isSuccessful);

    [id(DISPID_XMLDOM_DOCUMENT_SAVE), 
     helpstring("save the document to a specified destination")] 
    HRESULT save( 
        [in] VARIANT destination);

    [propget, id(DISPID_XMLDOM_DOCUMENT_VALIDATE), 
     helpstring("indicates whether the parser performs validation")] 
    HRESULT validateOnParse(
        [retval, out] VARIANT_BOOL * isValidating);

    [propput, id(DISPID_XMLDOM_DOCUMENT_VALIDATE), 
     helpstring("indicates whether the parser performs validation")] 
    HRESULT validateOnParse(
        [in] VARIANT_BOOL isValidating);

    [propget, id(DISPID_XMLDOM_DOCUMENT_RESOLVENAMESPACE),
     helpstring("indicates whether the parser resolves references to external DTD/Entities/Schema")]
    HRESULT resolveExternals(
        [retval,out] VARIANT_BOOL * isResolving);

    [propput, id(DISPID_XMLDOM_DOCUMENT_RESOLVENAMESPACE),
     helpstring("indicates whether the parser resolves references to external DTD/Entities/Schema")]
    HRESULT resolveExternals(
        [in] VARIANT_BOOL isResolving);

    [propget, id(DISPID_XMLDOM_DOCUMENT_PRESERVEWHITESPACE),
     helpstring("indicates whether the parser preserves whitespace")]
    HRESULT preserveWhiteSpace(
        [retval,out] VARIANT_BOOL * isPreserving);

    [propput, id(DISPID_XMLDOM_DOCUMENT_PRESERVEWHITESPACE),
     helpstring("indicates whether the parser preserves whitespace")]
    HRESULT preserveWhiteSpace(
        [in] VARIANT_BOOL isPreserving);

    [propput, id(DISPID_XMLDOM_DOCUMENT_ONREADYSTATECHANGE), 
     helpstring("register a readystatechange event handler")]
    HRESULT onreadystatechange(
        [in] VARIANT readystatechangeSink);
 
    [propput, id(DISPID_XMLDOM_DOCUMENT_ONDATAAVAILABLE), 
     helpstring("register an ondataavailable event handler")]
    HRESULT ondataavailable(
        [in] VARIANT ondataavailableSink);

    [propput, id(DISPID_XMLDOM_DOCUMENT_ONTRANSFORMNODE), 
     helpstring("register an ontransformnode event handler")]
    HRESULT ontransformnode(
        [in] VARIANT ontransformnodeSink);
};

[
    local, object,
    uuid(2933BF95-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMDocument2
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMDocument2 : IXMLDOMDocument
{
    [propget, id(DISPID_XMLDOM_DOCUMENT2_NAMESPACES),
     helpstring("A collection of all namespaces for this document")]
    HRESULT namespaces(
        [out,retval] IXMLDOMSchemaCollection ** namespaceCollection);

    [propget, id(DISPID_XMLDOM_DOCUMENT2_SCHEMAS),
     helpstring("The associated schema cache")]
    HRESULT schemas(
        [out,retval] VARIANT * otherCollection);

    [propputref, id(DISPID_XMLDOM_DOCUMENT2_SCHEMAS),
     helpstring("The associated schema cache")]
    HRESULT schemas(
        [in] VARIANT otherCollection);

    [id(DISPID_XMLDOM_DOCUMENT2_VALIDATE),
        helpstring("perform runtime validation on the currently loaded XML document")]
    HRESULT validate(
        [retval, out] IXMLDOMParseError ** errorObj);

    [id(DISPID_XMLDOM_DOCUMENT2_SETPROPERTY),
        helpstring("set the value of the named property")]
    HRESULT setProperty(
        [in] BSTR name,
        [in] VARIANT value);

    [id(DISPID_XMLDOM_DOCUMENT2_GETPROPERTY),
        helpstring("get the value of the named property")]
    HRESULT getProperty(
        [in] BSTR name,
        [out,retval] VARIANT * value);
};

[
    local, object,
    uuid(2933BF96-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMDocument3
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMDocument3 : IXMLDOMDocument2
{
    [id(DISPID_XMLDOM_DOCUMENT3_VALIDATENODE),
        helpstring("perform runtime validation on the currently loaded XML document node")]
    HRESULT validateNode(
        [in] IXMLDOMNode* node,
        [out, retval] IXMLDOMParseError ** errorObj);

    [id(DISPID_XMLDOM_DOCUMENT3_IMPORTNODE),
        helpstring("clone node such that clones ownerDocument is this document")]
    HRESULT importNode(
        [in] IXMLDOMNode* node,
        [in] VARIANT_BOOL deep,
        [out, retval] IXMLDOMNode** clone);
};

[
    local, object,
    uuid(373984c8-b845-449b-91e7-45ac83036ade),
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schemas Collection"),
    pointer_default(unique)
]
interface IXMLDOMSchemaCollection : IDispatch
{
    [id(DISPID_XMLDOM_SCHEMACOLLECTION_ADD), 
     helpstring("add a new schema")]
    HRESULT add(
        [in] BSTR namespaceURI,
        [in] VARIANT var);

    [id(DISPID_XMLDOM_SCHEMACOLLECTION_GET),
     helpstring("lookup schema by namespaceURI")]
    HRESULT get(
        [in] BSTR namespaceURI,
        [out,retval] IXMLDOMNode ** schemaNode);

    [id(DISPID_XMLDOM_SCHEMACOLLECTION_REMOVE),
     helpstring("remove schema by namespaceURI")]
    HRESULT remove(
        [in] BSTR namespaceURI);

    [id(DISPID_XMLDOM_SCHEMACOLLECTION_LENGTH),
     helpstring("number of schemas in collection"), propget]
    HRESULT length(
        [out, retval] long * length);

    [propget, id(DISPID_VALUE),
     helpstring("Get namespaceURI for schema by index")]
    HRESULT namespaceURI(
        [in] long index,
        [out, retval] BSTR * length);

    [id(DISPID_XMLDOM_SCHEMACOLLECTION_ADDCOLLECTION),
     helpstring("copy & merge other collection into this one")]
    HRESULT addCollection(
        [in] IXMLDOMSchemaCollection * otherCollection);

    [propget, restricted, hidden, 
     id(DISPID_NEWENUM)] 
    HRESULT _newEnum(
        [retval, out] IUnknown ** ppUnk);
};

[
    local, object,
    uuid(2933BF82-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMNodeList
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMNodeList : IDispatch
{
    // Node                      item(in unsigned long index);
    [propget, id(DISPID_VALUE),
     helpstring("collection of nodes")]
    HRESULT item(
        [in] long index,
        [out, retval] IXMLDOMNode ** listItem);

    // readonly attribute  unsigned long        length;
    [propget, id(DISPID_DOM_NODELIST_LENGTH),
     helpstring("number of nodes in the collection")]
    HRESULT length(
        [out, retval] long * listLength);

    [id(DISPID_XMLDOM_NODELIST_NEXTNODE),
     helpstring("get next node from iterator")]
    HRESULT nextNode(
        [out, retval] IXMLDOMNode ** nextItem);

    [id(DISPID_XMLDOM_NODELIST_RESET),
     helpstring("reset the position of iterator")]
    HRESULT reset();

    [propget, restricted, hidden, 
     id(DISPID_NEWENUM)] 
    HRESULT _newEnum(
        [retval, out] IUnknown ** ppUnk);
};


[
    local, object,
    uuid(AA634FC7-5888-44a7-A257-3A47150D3A0E), // IID_IXMLDOMSelection
    odl,
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMSelection : IXMLDOMNodeList
{
    [propget, id(DISPID_XMLDOM_SELECTION_EXPR),
     helpstring("selection expression")]
    HRESULT expr(
        [out, retval] BSTR * expression);

    [propput, id(DISPID_XMLDOM_SELECTION_EXPR),
     helpstring("selection expression")]
    HRESULT expr(
        [in] BSTR expression);

    [propget, id(DISPID_XMLDOM_SELECTION_CONTEXT),
     helpstring("nodes to apply selection expression to")]
    HRESULT context(
        [out, retval] IXMLDOMNode ** ppNode);

    [propputref, id(DISPID_XMLDOM_SELECTION_CONTEXT),
     helpstring("nodes to apply selection expression to")]
    HRESULT context(
        [in] IXMLDOMNode * pNode);

    [id(DISPID_XMLDOM_SELECTION_PEEKNODE),
     helpstring("gets the next node without advancing the list position")]
    HRESULT peekNode(
        [out, retval] IXMLDOMNode ** ppNode);

    [id(DISPID_XMLDOM_SELECTION_MATCHES),
     helpstring("checks to see if the node matches the pattern")]
    HRESULT matches(
        [in] IXMLDOMNode * pNode,
        [out, retval] IXMLDOMNode ** ppNode);

    [id(DISPID_XMLDOM_SELECTION_REMOVENEXT),
     helpstring("removes the next node")]
    HRESULT removeNext(
        [out, retval] IXMLDOMNode ** ppNode);

    [id(DISPID_XMLDOM_SELECTION_REMOVEALL),
     helpstring("removes all the nodes that match the selection")]
    HRESULT removeAll();

    [id(DISPID_XMLDOM_SELECTION_CLONE),
     helpstring("clone this object with the same position and context")]
    HRESULT clone(
        [out, retval] IXMLDOMSelection ** ppNode);

    [id(DISPID_XMLDOM_SELECTION_GETPROPERTY),
        helpstring("get the value of the named property")]
    HRESULT getProperty(
        [in] BSTR name,
        [out,retval] VARIANT * value);

    [id(DISPID_XMLDOM_SELECTION_SETPROPERTY),
        helpstring("set the value of the named property")]
    HRESULT setProperty(
        [in] BSTR name,
        [in] VARIANT value);
};


[
    local, object,
    uuid(2933BF83-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMNamedNodeMap
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMNamedNodeMap : IDispatch
{
    // Node                      getNamedItem(in wstring name);
    [id(DISPID_DOM_NAMEDNODEMAP_GETNAMEDITEM),
     helpstring("lookup item by name")]
    HRESULT getNamedItem(
        [in] BSTR name,
        [out, retval] IXMLDOMNode ** namedItem);

    // void                      setNamedItem(in Node arg);
    [id(DISPID_DOM_NAMEDNODEMAP_SETNAMEDITEM),
     helpstring("set item by name")]
    HRESULT setNamedItem(
        [in] IXMLDOMNode * newItem,
        [out, retval] IXMLDOMNode ** nameItem);

    // Node                      removeNamedItem(in wstring name);
    [id(DISPID_DOM_NAMEDNODEMAP_REMOVENAMEDITEM),
     helpstring("remove item by name")]
    HRESULT removeNamedItem(
        [in] BSTR name,
        [out, retval] IXMLDOMNode ** namedItem);

    // Node                      item(in unsigned long index);
    [propget, id(DISPID_VALUE),
     helpstring("collection of nodes")]
    HRESULT item(
        [in] long index,
        [out, retval] IXMLDOMNode ** listItem);

    // readonly attribute  unsigned long        length;
    [propget, id(DISPID_DOM_NODELIST_LENGTH),
     helpstring("number of nodes in the collection")]
    HRESULT length(
        [out, retval] long * listLength);

    // Node                      getQualifiedItem(in wstring name,in Node namespace);
    [id(DISPID_XMLDOM_NAMEDNODEMAP_GETQUALIFIEDITEM),
     helpstring("lookup the item by name and namespace")]
    HRESULT getQualifiedItem(
        [in] BSTR baseName,
        [in] BSTR namespaceURI,
        [out, retval] IXMLDOMNode ** qualifiedItem);

    // Node                      removeQualifiedItem(in wstring name,in Node namespace);
    [id(DISPID_XMLDOM_NAMEDNODEMAP_REMOVEQUALIFIEDITEM),
     helpstring("remove the item by name and namespace")]
    HRESULT removeQualifiedItem(
        [in] BSTR baseName,
        [in] BSTR namespaceURI,
        [out, retval] IXMLDOMNode ** qualifiedItem);

    [id(DISPID_XMLDOM_NAMEDNODEMAP_NEXTNODE),
     helpstring("get next node from iterator")]
    HRESULT nextNode(
        [out, retval] IXMLDOMNode ** nextItem);

    [id(DISPID_XMLDOM_NAMEDNODEMAP_RESET),
     helpstring("reset the position of iterator")]
    HRESULT reset();

    [propget, restricted, hidden, 
     id(DISPID_NEWENUM)] 
    HRESULT _newEnum(
        [retval, out] IUnknown ** ppUnk);
};


[
    local, object,
    uuid(3efaa413-272f-11d2-836f-0000f87a7782), // IID_IXMLDOMDocumentFragment
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMDocumentFragment : IXMLDOMNode 
{
};


[
    local, object,
    uuid(2933BF84-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMCharacterData
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMCharacterData : IXMLDOMNode 
{
    //          attribute  wstring              data;
    [propget, id(DISPID_DOM_DATA_DATA),
     helpstring("value of the node")]
    HRESULT data(
        [out, retval] BSTR * data);

    [propput, id(DISPID_DOM_DATA_DATA),
     helpstring("value of the node")]
    HRESULT data(
        [in] BSTR data);
    
    // readonly attribute  unsigned long        length;
    [propget, id(DISPID_DOM_DATA_LENGTH),
     helpstring("number of characters in value")]
    HRESULT length(
        [out, retval] long * dataLength);

    // wstring                   substring(in unsigned long offset, 
    //                                     in unsigned long count)
    //                                     raises(DOMException);
    [id(DISPID_DOM_DATA_SUBSTRING),
     helpstring("retrieve substring of value")]
    HRESULT substringData(
        [in] long offset,
        [in] long count,
        [out, retval] BSTR * data);

    // void                      append(in wstring arg);
    [id(DISPID_DOM_DATA_APPEND),
     helpstring("append string to value")]
    HRESULT appendData(
        [in] BSTR data);

    // void                      insert(in unsigned long offset, 
    //                                  in wstring arg)
    //                                  raises(DOMException);
    [id(DISPID_DOM_DATA_INSERT),
     helpstring("insert string into value")]
    HRESULT insertData(
        [in] long offset,
        [in] BSTR data);

    // void                      delete(in unsigned long offset, 
    //                                  in unsigned long count)
    //                                  raises(DOMException);
    [id(DISPID_DOM_DATA_DELETE),
     helpstring("delete string within the value")]
    HRESULT deleteData(
        [in] long offset,
        [in] long count);

    // void                      replace(in unsigned long offset, 
    //                                   in unsigned long count, 
    //                                   in wstring arg)
    //                                   raises(DOMException);
    [id(DISPID_DOM_DATA_REPLACE),
     helpstring("replace string within the value")]
    HRESULT replaceData(
        [in] long offset,
        [in] long count,
        [in] BSTR data);
};


[
    local, object,
    uuid(2933BF85-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMAttribute
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMAttribute : IXMLDOMNode 
{
    // wstring                   name;
    [propget, id(DISPID_DOM_ATTRIBUTE_GETNAME),
     helpstring("get name of the attribute")]
    HRESULT name(
        [out, retval] BSTR * attributeName);

    //         attribute  boolean              specified;
    // ! This is defined as an extended property on IXMLDOMNode

    // attribute wstring                   value;
    [propget, id(DISPID_DOM_ATTRIBUTE_VALUE),
     helpstring("string value of the attribute")]
    HRESULT value(
        [out, retval] VARIANT * attributeValue);

    [propput, id(DISPID_DOM_ATTRIBUTE_VALUE),
     helpstring("string value of the attribute")]
    HRESULT value(
        [in] VARIANT attributeValue);
};


[
    local, object,
    uuid(2933BF86-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMElement
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMElement : IXMLDOMNode 
{
    // readonly attribute wstring                   tagName;
    [propget, id(DISPID_DOM_ELEMENT_GETTAGNAME),
     helpstring("get the tagName of the element")]
    HRESULT tagName(
        [out, retval] BSTR * tagName);

    // wstring                   getAttribute(in wstring name);
    [id(DISPID_DOM_ELEMENT_GETATTRIBUTE),
     helpstring("look up the string value of an attribute by name")]
    HRESULT getAttribute(
        [in] BSTR name,
        [out, retval] VARIANT * value);

    // void                      setAttribute(in string name, 
    //                                        in string value);
    [id(DISPID_DOM_ELEMENT_SETATTRIBUTE),
     helpstring("set the string value of an attribute by name")]
    HRESULT setAttribute(
        [in] BSTR name,
        [in] VARIANT value);

    // void                      removeAttribute(in wstring name);
    [id(DISPID_DOM_ELEMENT_REMOVEATTRIBUTE),
     helpstring("remove an attribute by name")]
    HRESULT removeAttribute(
        [in] BSTR name);

    // Attribute                 getAttributeNode(in wstring name);
    [id(DISPID_DOM_ELEMENT_GETATTRIBUTENODE),
     helpstring("look up the attribute node by name")]
    HRESULT getAttributeNode(
        [in] BSTR name,
        [out, retval] IXMLDOMAttribute ** attributeNode);

    // void                      setAttributeNode(in Attribute newAttr);
    [id(DISPID_DOM_ELEMENT_SETATTRIBUTENODE),
     helpstring("set the specified attribute on the element")]
    HRESULT setAttributeNode(
        [in] IXMLDOMAttribute * DOMAttribute,
        [out, retval] IXMLDOMAttribute ** attributeNode);

    // void                      removeAttributeNode(in Attribute oldAttr);
    [id(DISPID_DOM_ELEMENT_REMOVEATTRIBUTENODE),
     helpstring("remove the specified attribute")]
    HRESULT removeAttributeNode(
        [in] IXMLDOMAttribute * DOMAttribute,
        [out, retval] IXMLDOMAttribute ** attributeNode);

    // NodeList                  getElementsByTagName(in wstring tagname);
    [id(DISPID_DOM_ELEMENT_GETELEMENTSBYTAGNAME),
     helpstring("build a list of elements by name")]
    HRESULT getElementsByTagName(
        [in] BSTR tagName,
        [out, retval] IXMLDOMNodeList ** resultList);

    // void                      normalize();
    [id(DISPID_DOM_ELEMENT_NORMALIZE),
     helpstring("collapse all adjacent text nodes in sub-tree")]
    HRESULT normalize();
};


[
    local, object,
    uuid(2933BF87-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMText
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMText : IXMLDOMCharacterData 
{
    // Text                      splitText(in unsigned long offset);
    [id(DISPID_DOM_TEXT_SPLITTEXT),
     helpstring("split the text node into two text nodes at the position specified")]
    HRESULT splitText(
        [in] long offset,
        [out, retval] IXMLDOMText ** rightHandTextNode);
};


[
    local, object,
    uuid(2933BF88-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMComment
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMComment : IXMLDOMCharacterData 
{
};


[
    local, object,
    uuid(2933BF89-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMProcessingInstruction
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMProcessingInstruction : IXMLDOMNode 
{
    //         read-only attribute  wstring              target;
    [propget, id(DISPID_DOM_PI_TARGET),
     helpstring("the target")]
    HRESULT target(
        [out, retval] BSTR * name);

    //         attribute  wstring              data;
    [propget, id(DISPID_DOM_PI_DATA),
     helpstring("the data")]
    HRESULT data(
        [out, retval] BSTR * value);

    [propput, id(DISPID_DOM_PI_DATA),
     helpstring("the data")]
    HRESULT data(
        [in] BSTR value);
};


[
    local, object,
    uuid(2933BF8A-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMCDATASection
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMCDATASection : IXMLDOMText 
{
};


[
    local, object,
    uuid(2933BF8B-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMDocumentType
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMDocumentType : IXMLDOMNode 
{
    //          readonly attribute  wstring              name;
    [propget, id(DISPID_DOM_DOCUMENTTYPE_NAME),
     helpstring("name of the document type (root of the tree)")]
    HRESULT name(
        [out, retval] BSTR * rootName);

    // readonly attribute  NamedNodeMap         entities;
    [propget, id(DISPID_DOM_DOCUMENTTYPE_ENTITIES),
     helpstring("a list of entities in the document")]
    HRESULT entities(
        [out, retval] IXMLDOMNamedNodeMap ** entityMap);

    // readonly attribute  NamedNodeMap         notations;
    [propget, id(DISPID_DOM_DOCUMENTTYPE_NOTATIONS),
     helpstring("a list of notations in the document")]
    HRESULT notations(
        [out, retval] IXMLDOMNamedNodeMap ** notationMap);
};


[
    local, object,
    uuid(2933BF8C-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMNotation
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMNotation : IXMLDOMNode 
{
    //         attribute  wstring              publicId;
    [propget, id(DISPID_DOM_NOTATION_PUBLICID),
     helpstring("the public ID")]
    HRESULT publicId(
        [out, retval] VARIANT * publicID);

    //         attribute  wstring              systemId;
    [propget, id(DISPID_DOM_NOTATION_SYSTEMID),
     helpstring("the system ID")]
    HRESULT systemId(
        [out, retval] VARIANT * systemID);
};


[
    local, object,
    uuid(2933BF8D-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMEntity
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMEntity : IXMLDOMNode 
{
    //         attribute  wstring              publicId;
    [propget, id(DISPID_DOM_ENTITY_PUBLICID),
     helpstring("the public ID")]
    HRESULT publicId(
        [out, retval] VARIANT * publicID);

    //         attribute  wstring              systemId;
    [propget, id(DISPID_DOM_ENTITY_SYSTEMID),
     helpstring("the system ID")]
    HRESULT systemId(
        [out, retval] VARIANT * systemID);

    //         attribute  wstring              notationName;
    [propget, id(DISPID_DOM_ENTITY_NOTATIONNAME),
     helpstring("the name of the notation")]
    HRESULT notationName(
        [out, retval] BSTR * name);
};


[
    local, object,
    uuid(2933BF8E-7B36-11d2-B20E-00C04F983E60), // IID_IXMLDOMEntityReference
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IXMLDOMEntityReference : IXMLDOMNode 
{
};

[
    local, object,
    nonextensible,
    pointer_default(unique),
    odl,
    oleautomation,
    dual,
    uuid(2933BF8F-7B36-11d2-B20E-00C04F983E60) // IID_IXMLDOMImplementation
]
interface IXMLDOMImplementation : IDispatch
{
    //  boolean                   hasFeature(in wstring feature, 
    //                                   in wstring version);
    [id(DISPID_DOM_IMPLEMENTATION_HASFEATURE)]
    HRESULT hasFeature(
        [in] BSTR feature,
        [in] BSTR version,
        [out, retval] VARIANT_BOOL * hasFeature);
};


[
    local, object,
    uuid(3efaa425-272f-11d2-836f-0000f87a7782), // IID_IXTLRuntime
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XTL runtime object"),
    pointer_default(unique)
]
interface IXTLRuntime : IXMLDOMNode 
{
    [id(DISPID_XTLRUNTIME_UNIQUEID),
     helpstring("")] 
    HRESULT uniqueID(
        [in]IXMLDOMNode *pNode, 
        [out,retval]long *pID);

    [id(DISPID_XTLRUNTIME_DEPTH),
     helpstring("")]
    HRESULT depth(
        [in] IXMLDOMNode *pNode, 
        [out,retval]long * pDepth);

    [id(DISPID_XTLRUNTIME_CHILDNUMBER),
     helpstring("")] 
    HRESULT childNumber(
        [in]IXMLDOMNode *pNode, 
        [out,retval] long *pNumber);

    [id(DISPID_XTLRUNTIME_ANCESTORCHILDNUMBER),
     helpstring("")] 
    HRESULT ancestorChildNumber(
        [in]BSTR bstrNodeName, 
        [in]IXMLDOMNode *pNode, 
        [out,retval]long *pNumber);

    [id(DISPID_XTLRUNTIME_ABSOLUTECHILDNUMBER),
     helpstring("")] 
    HRESULT absoluteChildNumber(
        [in]IXMLDOMNode *pNode, 
        [out,retval]long *pNumber);

    [id(DISPID_XTLRUNTIME_FORMATINDEX),
     helpstring("")] 
    HRESULT formatIndex(
        [in] long lIndex, 
        [in] BSTR bstrFormat, 
        [out, retval]BSTR *pbstrFormattedString);

    [id(DISPID_XTLRUNTIME_FORMATNUMBER),
     helpstring("")] 
    HRESULT formatNumber(
        [in] double dblNumber, 
        [in] BSTR bstrFormat, 
        [out, retval]BSTR *pbstrFormattedString);

    [id(DISPID_XTLRUNTIME_FORMATDATE),
     helpstring("")] 
    HRESULT formatDate(
        [in] VARIANT varDate, 
        [in] BSTR bstrFormat, 
        [in,optional] VARIANT varDestLocale,
        [out, retval]BSTR *pbstrFormattedString);

    [id(DISPID_XTLRUNTIME_FORMATTIME),
     helpstring("")] 
    HRESULT formatTime(
        [in] VARIANT varTime, 
        [in] BSTR bstrFormat, 
        [in,optional] VARIANT varDestLocale,
        [out, retval]BSTR *pbstrFormattedString);
};

[
    local, object,
    uuid(3efaa426-272f-11d2-836f-0000f87a7782), // IID_IXMLDOMParseError
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("structure for reporting parser errors"),
    pointer_default(unique)
]
interface IXMLDOMParseError : IDispatch
{
    [propget, id(DISPID_VALUE), 
     helpstring("the error code")] 
    HRESULT errorCode(
        [retval, out] long * errorCode);

    [propget, id(DISPID_DOM_ERROR_URL), 
     helpstring("the URL of the XML document containing the error")] 
    HRESULT url(
        [retval, out] BSTR * urlString);

    [propget, id(DISPID_DOM_ERROR_REASON), 
     helpstring("the cause of the error")] 
    HRESULT reason(
        [retval, out] BSTR * reasonString);

    [propget, id(DISPID_DOM_ERROR_SRCTEXT), 
     helpstring("the data where the error occurred")] 
    HRESULT srcText(
        [retval, out] BSTR * sourceString);

    [propget, id(DISPID_DOM_ERROR_LINE), 
     helpstring("the line number in the XML document where the error occurred")] 
    HRESULT line(
        [retval, out] long * lineNumber);

    [propget, id(DISPID_DOM_ERROR_LINEPOS),
     helpstring("the character position in the line containing the error")] 
    HRESULT linepos(
        [retval, out] long * linePosition);

    [propget, id(DISPID_DOM_ERROR_FILEPOS), 
     helpstring("the absolute file position in the XML document containing the error")]
    HRESULT filepos(
        [retval, out] long * filePosition);
};

[
    local, object,
    uuid(3efaa428-272f-11d2-836f-0000f87a7782), // IID_IXMLDOMParseError2
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("structure for reporting parser errors"),
    pointer_default(unique)
]
interface IXMLDOMParseError2 : IXMLDOMParseError
{
    [propget, id(DISPID_DOM_ERROR2_ERRORXPATH)]
    HRESULT errorXPath(
        [out, retval] BSTR * xpathexpr);

    [propget, id(DISPID_DOM_ERROR2_ALLERRORS)]
    HRESULT allErrors(
        [out, retval] IXMLDOMParseErrorCollection ** allErrors);

    [id(DISPID_DOM_ERROR2_ERRORPARAMETERS)]
    HRESULT errorParameters(
        [in] long index,
        [out,retval] BSTR* param);

    [propget, id(DISPID_DOM_ERROR2_ERRORPARAMETERSCOUNT)]
    HRESULT errorParametersCount(
        [out,retval] long* count);
};


[
    local, object,
    uuid(3efaa429-272f-11d2-836f-0000f87a7782), // IID_IXMLDOMParseErrorCollection
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("structure for reporting parser errors"),
    pointer_default(unique)
]
interface IXMLDOMParseErrorCollection : IDispatch
{
    [id(DISPID_VALUE), propget]                       HRESULT item([in]long index, [out,retval]IXMLDOMParseError2 ** error);
    [id(DISPID_DOM_ERRORCOLLECTION_LENGTH), propget]  HRESULT length([out,retval]long * length);
    [id(DISPID_DOM_ERRORCOLLECTION_NEXT), propget]    HRESULT next([out, retval] IXMLDOMParseError2 ** error);
    [id(DISPID_DOM_ERRORCOLLECTION_RESET)]            HRESULT reset();
    [id(DISPID_NEWENUM), hidden, restricted, propget] HRESULT _newEnum([out,retval]IUnknown ** ppunk);
};

// DOM event interface
[
    hidden,
    uuid(3efaa427-272f-11d2-836f-0000f87a7782) // IID_IXMLDOMEvent
]
dispinterface XMLDOMDocumentEvents 
{
    properties:
    methods:
    [id (DISPID_XMLDOMEVENT_ONDATAAVAILABLE)]  
    HRESULT ondataavailable(void);
 
    [id (DISPID_XMLDOMEVENT_ONREADYSTATECHANGE)] 
    HRESULT onreadystatechange(void);
};


[
    local, object,
    uuid(2933BF92-7B36-11d2-B20E-00C04F983E60), // IXSLProcessor
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("IXSLProcessor Interface"),
    pointer_default(unique)
]
interface IXSLProcessor : IDispatch
{
    [propput, id(DISPID_XMLDOM_PROCESSOR_INPUT), helpstring("XML input tree to transform")]
    HRESULT input([in] VARIANT var);

    [propget, id(DISPID_XMLDOM_PROCESSOR_INPUT), helpstring("XML input tree to transform")]
    HRESULT input([out,retval] VARIANT * pVar);

    [propget, id(DISPID_XMLDOM_PROCESSOR_XSLTEMPLATE), helpstring("template object used to create this processor object")]
    HRESULT ownerTemplate([out,retval] IXSLTemplate** ppTemplate);

    [id(DISPID_XMLDOM_PROCESSOR_SETSTARTMODE), helpstring("set XSL mode and it's namespace")]
    HRESULT setStartMode([in] BSTR mode, 
                         [in, defaultvalue("")] BSTR namespaceURI);

    [propget, id(DISPID_XMLDOM_PROCESSOR_STARTMODE), helpstring("starting XSL mode")]
    HRESULT startMode([out, retval] BSTR * mode);

    [propget, id(DISPID_XMLDOM_PROCESSOR_STARTMODEURI), helpstring("namespace of starting XSL mode")]
    HRESULT startModeURI([out, retval] BSTR * namespaceURI);

    [propput, id(DISPID_XMLDOM_PROCESSOR_OUTPUT), helpstring("custom stream object for transform output")]
    HRESULT output([in] VARIANT output);

    [propget, id(DISPID_XMLDOM_PROCESSOR_OUTPUT), helpstring("transform output")]
    HRESULT output([out, retval] VARIANT* pOutput);

    [id(DISPID_XMLDOM_PROCESSOR_TRANSFORM), helpstring("start/resume the XSL transformation process")]
    HRESULT transform([out,retval] VARIANT_BOOL* pDone);

    [id(DISPID_XMLDOM_PROCESSOR_RESET), helpstring("reset state of processor and abort current transform")]
    HRESULT reset();

    [propget, id(DISPID_XMLDOM_PROCESSOR_READYSTATE), helpstring("current state of the processor")]
    HRESULT readyState([out, retval] long* pReadyState);

    [id(DISPID_XMLDOM_PROCESSOR_ADDPARAMETER), helpstring("set <xsl:param> values")]
    HRESULT addParameter([in] BSTR baseName, 
                     [in] VARIANT parameter, 
                     [in, defaultvalue("")] BSTR namespaceURI);

    [id(DISPID_XMLDOM_PROCESSOR_ADDOBJECT), helpstring("pass object to stylesheet")]
    HRESULT addObject([in] IDispatch* obj, 
                  [in] BSTR namespaceURI);

    [propget, id(DISPID_XMLDOM_PROCESSOR_STYLESHEET), helpstring("current stylesheet being used")]
    HRESULT stylesheet([out,retval] IXMLDOMNode** stylesheet);
}; 


[
    local, object,
    uuid(2933BF93-7B36-11d2-B20E-00C04F983E60), // IID_IXSLTemplate
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("IXSLTemplate Interface"),
    pointer_default(unique)
]
interface IXSLTemplate : IDispatch
{
    [propputref, id(DISPID_XMLDOM_TEMPLATE_STYLESHEET), helpstring("stylesheet to use with processors")]
    HRESULT stylesheet([in] IXMLDOMNode* stylesheet);

    [propget, id(DISPID_XMLDOM_TEMPLATE_STYLESHEET), helpstring("stylesheet to use with processors")]
    HRESULT stylesheet([out, retval] IXMLDOMNode** stylesheet);

    [id(DISPID_XMLDOM_TEMPLATE_CREATEPROCESSOR), helpstring("create a new processor object")]
    HRESULT createProcessor([out, retval] IXSLProcessor** ppProcessor);
}; 

[
    local, object,
    uuid(310afa62-0575-11d2-9ca9-0060b0ec3d39),
    odl,
    dual,
    oleautomation,
    nonextensible,
    hidden, // Because that this is the default interface of coclass DSOControl
    helpstring("DSO Control"),
    pointer_default(unique)
]
interface IDSOControl : IDispatch
{
    [propget,id(DISPID_XMLDSO_DOCUMENT)] 
        HRESULT XMLDocument([out, retval] IXMLDOMDocument** ppDoc);
    [propput,id(DISPID_XMLDSO_DOCUMENT)] 
        HRESULT XMLDocument([in] IXMLDOMDocument* ppDoc);

    [propget,id(DISPID_XMLDSO_JAVADSOCOMPATIBLE)] 
        HRESULT JavaDSOCompatible([out, retval] BOOL* fJavaDSOCompatible);
    [propput,id(DISPID_XMLDSO_JAVADSOCOMPATIBLE)] 
        HRESULT JavaDSOCompatible([in]  BOOL fJavaDSOCompatible);

    [propget, id(DISPID_READYSTATE)] 
        HRESULT readyState([out, retval] long *state);
};

[
    object,
    uuid(ED8C108D-4349-11D2-91A4-00C04F7969E8),
    odl,
    dual,
    oleautomation,
    helpstring("IXMLHTTPRequest Interface"),
    pointer_default(unique)
]
interface IXMLHTTPRequest : IDispatch
{
    [id(1), helpstring("Open HTTP connection")] HRESULT open([in] BSTR bstrMethod, [in] BSTR bstrUrl, [in,optional] VARIANT varAsync, [in,optional] VARIANT bstrUser, [in,optional] VARIANT bstrPassword);
    [id(2), helpstring("Add HTTP request header")] HRESULT setRequestHeader([in] BSTR bstrHeader, [in] BSTR bstrValue);
    [id(3), helpstring("Get HTTP response header")] HRESULT getResponseHeader([in] BSTR bstrHeader, [out, retval] BSTR * pbstrValue);
    [id(4), helpstring("Get all HTTP response headers")] HRESULT getAllResponseHeaders([out, retval] BSTR * pbstrHeaders);
    [id(5), helpstring("Send HTTP request")] HRESULT send([in, optional] VARIANT varBody);
    [id(6), helpstring("Abort HTTP request")] HRESULT abort();
    [propget, id(7),  helpstring("Get HTTP status code")] HRESULT status([out, retval] long * plStatus);
    [propget, id(8),  helpstring("Get HTTP status text")] HRESULT statusText([out, retval] BSTR * pbstrStatus);
    [propget, id(9),  helpstring("Get response body")] HRESULT responseXML([out, retval] IDispatch ** ppBody);
    [propget, id(10),  helpstring("Get response body")] HRESULT responseText([out, retval] BSTR * pbstrBody);
    [propget, id(11), helpstring("Get response body")] HRESULT responseBody([out, retval] VARIANT * pvarBody);
    [propget, id(12), helpstring("Get response body")] HRESULT responseStream([out, retval] VARIANT * pvarBody);
    [propget, id(13), helpstring("Get ready state")] HRESULT readyState([out, retval] long * plState);
    [propput, id(14), helpstring("Register a complete event handler")] HRESULT onreadystatechange([in] IDispatch * pReadyStateSink);
};

cpp_quote("#if !defined(__msxml_sxh_enums__)")
cpp_quote("#define __msxml_sxh_enums__")
typedef [
    helpstring("Options for ServerXMLHTTPRequest Option property")
]
enum _SERVERXMLHTTP_OPTION
{
    SXH_OPTION_URL = -1,
    SXH_OPTION_URL_CODEPAGE,
    SXH_OPTION_ESCAPE_PERCENT_IN_URL,
    SXH_OPTION_IGNORE_SERVER_SSL_CERT_ERROR_FLAGS,
    SXH_OPTION_SELECT_CLIENT_SSL_CERT
} SERVERXMLHTTP_OPTION;

typedef [
    helpstring("Flags for SXH_OPTION_IGNORE_SERVER_SSL_CERT_ERROR_FLAGS option")
]
enum _SXH_SERVER_CERT_OPTION
{
    SXH_SERVER_CERT_IGNORE_UNKNOWN_CA        = 0x00000100,
    SXH_SERVER_CERT_IGNORE_WRONG_USAGE       = 0x00000200,
    SXH_SERVER_CERT_IGNORE_CERT_CN_INVALID   = 0x00001000,
    SXH_SERVER_CERT_IGNORE_CERT_DATE_INVALID = 0x00002000,
    SXH_SERVER_CERT_IGNORE_ALL_SERVER_ERRORS = (SXH_SERVER_CERT_IGNORE_UNKNOWN_CA
                                              + SXH_SERVER_CERT_IGNORE_WRONG_USAGE
                                              + SXH_SERVER_CERT_IGNORE_CERT_CN_INVALID
                                              + SXH_SERVER_CERT_IGNORE_CERT_DATE_INVALID)
} SXH_SERVER_CERT_OPTION;

typedef [
    helpstring("Settings for setProxy")
]
enum _SXH_PROXY_SETTING
{
    SXH_PROXY_SET_DEFAULT   = 0x00000000,
    SXH_PROXY_SET_PRECONFIG = 0x00000000,
    SXH_PROXY_SET_DIRECT    = 0x00000001,
    SXH_PROXY_SET_PROXY     = 0x00000002
} SXH_PROXY_SETTING;
cpp_quote("#endif // !defined(__msxml_sxh_enums__)")


[
    object,
    uuid(2e9196bf-13ba-4dd4-91ca-6c571f281495),
    odl,
    dual,
    oleautomation,
    helpstring("IServerXMLHTTPRequest Interface"),
    pointer_default(unique)
]
interface IServerXMLHTTPRequest : IXMLHTTPRequest
{
    [id(15), helpstring("Specify timeout settings (in milliseconds)")]
    HRESULT setTimeouts([in] long resolveTimeout, [in] long connectTimeout, [in] long sendTimeout, [in] long receiveTimeout);

    [id(16), helpstring("Wait for asynchronous send to complete, with optional timeout (in seconds)")]
    HRESULT waitForResponse([in, optional] VARIANT timeoutInSeconds, [out, retval] VARIANT_BOOL * isSuccessful);

    [id(17), helpstring("Get an option value")]
    HRESULT getOption([in] SERVERXMLHTTP_OPTION option, [out, retval] VARIANT * value);

    [id(18), helpstring("Set an option value")]
    HRESULT setOption([in] SERVERXMLHTTP_OPTION option, [in] VARIANT value);
};

[
    object,
    uuid(2e01311b-c322-4b0a-bd77-b90cfdc8dce7),
    odl,
    dual,
    oleautomation,
    helpstring("IServerXMLHTTPRequest2 Interface"),
    pointer_default(unique)
]
interface IServerXMLHTTPRequest2 : IServerXMLHTTPRequest
{
    [id(19), helpstring("Specify proxy configuration")]
    HRESULT setProxy(
                [in] SXH_PROXY_SETTING proxySetting,
                [in, optional] VARIANT varProxyServer,
                [in, optional] VARIANT varBypassList);

    [id(20), helpstring("Specify proxy authentication credentials")]
    HRESULT setProxyCredentials(
                [in] BSTR bstrUserName,
                [in] BSTR bstrPassword);
};

//+-----------------------------------------------------------------------------
// 
// SAX interfaces
// 
//------------------------------------------------------------------------------

[
    hidden, 
    object,
    local,
    uuid(a4f96ed0-f829-476e-81c0-cdc7bd2a0802), // IID_ISAXXMLReader
    helpstring("ISAXXMLReader interface"),
    pointer_default(unique)
]
interface ISAXXMLReader : IUnknown
{
    HRESULT getFeature( 
        [in] const wchar_t * pwchName, 
        [out, retval] VARIANT_BOOL * pvfValue);
    HRESULT putFeature(
        [in] const wchar_t * pwchName, 
        [in] VARIANT_BOOL vfValue);

    HRESULT getProperty(
        [in] const wchar_t * pwchName,
        [out, retval] VARIANT * pvarValue);
    HRESULT putProperty(
        [in] const wchar_t * pwchName,
        [in] VARIANT varValue);

    HRESULT getEntityResolver(
        [out, retval] ISAXEntityResolver ** ppResolver);
    HRESULT putEntityResolver(
        [in] ISAXEntityResolver * pResolver);

    HRESULT getContentHandler(
        [out, retval] ISAXContentHandler ** ppHandler);
    HRESULT putContentHandler(
        [in] ISAXContentHandler * pHandler);

    HRESULT getDTDHandler(
        [out, retval] ISAXDTDHandler ** ppHandler);
    HRESULT putDTDHandler(
        [in] ISAXDTDHandler * pHandler);

    HRESULT getErrorHandler(
        [out, retval] ISAXErrorHandler ** ppHandler);
    HRESULT putErrorHandler(
        [in] ISAXErrorHandler * pHandler);

    HRESULT getBaseURL(
        [out, retval] const wchar_t ** ppwchBaseUrl);
    HRESULT putBaseURL(
        [in] const wchar_t * pwchBaseUrl);

    HRESULT getSecureBaseURL(
        [out, retval] const wchar_t ** ppwchSecureBaseUrl);
    HRESULT putSecureBaseURL(
        [in] const wchar_t * pwchSecureBaseUrl);

    HRESULT parse(
        [in, optional] VARIANT varInput);
    HRESULT parseURL(
        [in] const wchar_t * pwchUrl);
};

[
    hidden, 
    object,
    local,
    uuid(70409222-ca09-4475-acb8-40312fe8d145), // IID_ISAXXMLFilter
    helpstring("ISAXXMLFilter interface"),
    pointer_default(unique)
]
interface ISAXXMLFilter : ISAXXMLReader
{
    HRESULT getParent(
        [out, retval] ISAXXMLReader ** ppReader);
    HRESULT putParent(
        [in] ISAXXMLReader * pReader);
};

[
    hidden, 
    object,
    local,
    uuid(9b7e472a-0de4-4640-bff3-84d38a051c31), // IID_ISAXLocator
    helpstring("ISAXLocator interface"),
    pointer_default(unique)
]
interface ISAXLocator : IUnknown
{   
    HRESULT getColumnNumber(
        [out, retval] int * pnColumn);

    HRESULT getLineNumber(
        [out, retval] int * pnLine);

    HRESULT getPublicId(
        [out, retval] const wchar_t ** ppwchPublicId);

    HRESULT getSystemId(
        [out, retval] const wchar_t ** ppwchSystemId);
};

[
    hidden, 
    object,
    local,
    uuid(99bca7bd-e8c4-4d5f-a0cf-6d907901ff07), // IID_ISAXEntityResolver
    helpstring("ISAXEntityResolver interface"),
    pointer_default(unique)
]
interface ISAXEntityResolver : IUnknown
{   
    HRESULT resolveEntity(
        [in] const wchar_t * pwchPublicId,
        [in] const wchar_t * pwchSystemId,
        [out, retval] VARIANT * pvarInput);
};

[
    hidden, 
    object,
    local,
    uuid(1545cdfa-9e4e-4497-a8a4-2bf7d0112c44), // IID_ISAXContentHandler
    helpstring("ISAXContentHandler interface"),
    pointer_default(unique)
]
interface ISAXContentHandler : IUnknown
{
    HRESULT putDocumentLocator(
        [in] ISAXLocator * pLocator);

    HRESULT startDocument();

    HRESULT endDocument();

    HRESULT startPrefixMapping(
        [in] const wchar_t * pwchPrefix,
        [in] int cchPrefix,
        [in] const wchar_t * pwchUri,
        [in] int cchUri);

    HRESULT endPrefixMapping(
        [in] const wchar_t * pwchPrefix,
        [in] int cchPrefix);

    HRESULT startElement(
        [in] const wchar_t * pwchNamespaceUri, 
        [in] int cchNamespaceUri, 
        [in] const wchar_t * pwchLocalName, 
        [in] int cchLocalName, 
        [in] const wchar_t * pwchQName, 
        [in] int cchQName, 
        [in] ISAXAttributes * pAttributes);

    HRESULT endElement(
        [in] const wchar_t * pwchNamespaceUri, 
        [in] int cchNamespaceUri, 
        [in] const wchar_t * pwchLocalName, 
        [in] int cchLocalName, 
        [in] const wchar_t * pwchQName, 
        [in] int cchQName);

    HRESULT characters(
        [in] const wchar_t * pwchChars, 
        [in] int cchChars);

    HRESULT ignorableWhitespace(
        [in] const wchar_t * pwchChars, 
        [in] int cchChars);

    HRESULT processingInstruction(
        [in] const wchar_t * pwchTarget, 
        [in] int cchTarget,
        [in] const wchar_t * pwchData, 
        [in] int cchData);

    HRESULT skippedEntity(
        [in] const wchar_t * pwchName, 
        [in] int cchName);
};

[
    hidden, 
    object,
    local,
    uuid(e15c1baf-afb3-4d60-8c36-19a8c45defed), // IID_ISAXDTDHandler
    helpstring("ISAXDTDHandler interface"),
    pointer_default(unique)
]
interface ISAXDTDHandler : IUnknown
{   
    HRESULT notationDecl(
        [in] const wchar_t * pwchName,
        [in] int cchName,
        [in] const wchar_t * pwchPublicId,
        [in] int cchPublicId,
        [in] const wchar_t * pwchSystemId,
        [in] int cchSystemId);

    HRESULT unparsedEntityDecl(
        [in] const wchar_t * pwchName,
        [in] int cchName,
        [in] const wchar_t * pwchPublicId,
        [in] int cchPublicId,
        [in] const wchar_t * pwchSystemId,
        [in] int cchSystemId,
        [in] const wchar_t * pwchNotationName,
        [in] int cchNotationName);
};

[
    hidden, 
    object,
    local,
    uuid(a60511c4-ccf5-479e-98a3-dc8dc545b7d0), // IID_ISAXErrorHandler
    helpstring("ISAXErrorHandler interface"),
    pointer_default(unique)
]
interface ISAXErrorHandler : IUnknown
{   
    HRESULT error(
        [in] ISAXLocator * pLocator, 
        [in] const wchar_t * pwchErrorMessage,
        [in] HRESULT hrErrorCode);

    HRESULT fatalError(
        [in] ISAXLocator * pLocator, 
        [in] const wchar_t * pwchErrorMessage,
        [in] HRESULT hrErrorCode);

    HRESULT ignorableWarning( 
        [in] ISAXLocator * pLocator, 
        [in] const wchar_t * pwchErrorMessage, 
        [in] HRESULT hrErrorCode);
};

[
    hidden, 
    object,
    local,
    uuid(7f85d5f5-47a8-4497-bda5-84ba04819ea6), // IID_ISAXLexicalHandler
    helpstring("ISAXLexicalHandler interface"),
    pointer_default(unique)
]
interface ISAXLexicalHandler : IUnknown 
{
    HRESULT startDTD(
        [in] const wchar_t * pwchName,
        [in] int cchName,
        [in] const wchar_t * pwchPublicId,
        [in] int cchPublicId,
        [in] const wchar_t * pwchSystemId,
        [in] int cchSystemId);

    HRESULT endDTD();
    
    HRESULT startEntity(
        [in] const wchar_t * pwchName,
        [in] int cchName);

    HRESULT endEntity(
        [in] const wchar_t * pwchName,
        [in] int cchName);
    
    HRESULT startCDATA();

    HRESULT endCDATA();
    
    HRESULT comment(
        [in] const wchar_t * pwchChars, 
        [in] int cchChars);
};

[
    hidden, 
    object,
    local,
    uuid(862629ac-771a-47b2-8337-4e6843c1be90), // IID_ISAXDeclHandler
    helpstring("ISAXDeclHandler interface"),
    pointer_default(unique)
]
interface ISAXDeclHandler : IUnknown 
{
    HRESULT elementDecl(
        [in] const wchar_t * pwchName,
        [in] int cchName,
        [in] const wchar_t * pwchModel,
        [in] int cchModel);
    
    HRESULT attributeDecl(
        [in] const wchar_t * pwchElementName,
        [in] int cchElementName,
        [in] const wchar_t * pwchAttributeName,
        [in] int cchAttributeName,
        [in] const wchar_t * pwchType,
        [in] int cchType,
        [in] const wchar_t * pwchValueDefault,
        [in] int cchValueDefault,
        [in] const wchar_t * pwchValue,
        [in] int cchValue);
    
    HRESULT internalEntityDecl(
        [in] const wchar_t * pwchName,
        [in] int cchName,
        [in] const wchar_t * pwchValue,
        [in] int cchValue);

    HRESULT externalEntityDecl(
        [in] const wchar_t * pwchName,
        [in] int cchName,
        [in] const wchar_t * pwchPublicId,
        [in] int cchPublicId,
        [in] const wchar_t * pwchSystemId,
        [in] int cchSystemId);
};

[
    hidden, 
    object,
    local,
    uuid(f078abe1-45d2-4832-91ea-4466ce2f25c9), // IID_ISAXAttributes
    helpstring("ISAXAttributes interface"),
    pointer_default(unique)
]
interface ISAXAttributes : IUnknown
{   
    HRESULT getLength(
        [out, retval] int * pnLength);

    HRESULT getURI(
        [in] int nIndex,
        [out] const wchar_t ** ppwchUri,
        [out] int * pcchUri);

    HRESULT getLocalName(
        [in] int nIndex,
        [out] const wchar_t ** ppwchLocalName,
        [out] int * pcchLocalName);

    HRESULT getQName(
        [in] int nIndex,
        [out] const wchar_t ** ppwchQName,
        [out] int * pcchQName);

    HRESULT getName(
        [in] int nIndex,
        [out] const wchar_t ** ppwchUri,
        [out] int * pcchUri,
        [out] const wchar_t ** ppwchLocalName,
        [out] int * pcchLocalName,
        [out] const wchar_t ** ppwchQName,
        [out] int * pcchQName);

    HRESULT getIndexFromName(
        [in] const wchar_t * pwchUri,
        [in] int cchUri,
        [in] const wchar_t * pwchLocalName,
        [in] int cchLocalName,
        [out, retval] int * pnIndex);

    HRESULT getIndexFromQName(
        [in] const wchar_t * pwchQName,
        [in] int cchQName,
        [out, retval] int * pnIndex);

    HRESULT getType(
        [in] int nIndex,
        [out] const wchar_t ** ppwchType,
        [out] int * pcchType);

    HRESULT getTypeFromName(
        [in] const wchar_t * pwchUri,
        [in] int cchUri,
        [in] const wchar_t * pwchLocalName,
        [in] int cchLocalName,
        [out] const wchar_t ** ppwchType,
        [out] int * pcchType);

    HRESULT getTypeFromQName(
        [in] const wchar_t * pwchQName,
        [in] int cchQName,
        [out] const wchar_t ** ppwchType,
        [out] int * pcchType);

    HRESULT getValue(
        [in] int nIndex,
        [out] const wchar_t ** ppwchValue,
        [out] int * pcchValue);

    HRESULT getValueFromName(
        [in] const wchar_t * pwchUri,
        [in] int cchUri,
        [in] const wchar_t * pwchLocalName,
        [in] int cchLocalName,
        [out] const wchar_t ** ppwchValue,
        [out] int * pcchValue);

    HRESULT getValueFromQName(
        [in] const wchar_t * pwchQName,
        [in] int cchQName,
        [out] const wchar_t ** ppwchValue,
        [out] int * pcchValue);
};

//+-----------------------------------------------------------------------------
// 
// SAX dispatch interfaces
// 
//------------------------------------------------------------------------------

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(8c033caa-6cd6-4f73-b728-4531af74945f), // IID_IVBSAXXMLReader
    helpstring("IVBSAXXMLReader interface"),
    pointer_default(unique)
]
interface IVBSAXXMLReader : IDispatch
{
    [id(DISPID_SAX_XMLREADER_GETFEATURE), helpstring("Look up the value of a feature.")]
    HRESULT getFeature( 
        [in] BSTR strName, 
        [out, retval] VARIANT_BOOL * fValue);
    [id(DISPID_SAX_XMLREADER_PUTFEATURE), helpstring("Set the state of a feature.")]
    HRESULT putFeature(
        [in] BSTR strName, 
        [in] VARIANT_BOOL fValue);

    [id(DISPID_SAX_XMLREADER_GETPROPERTY), helpstring("Look up the value of a property.")]
    HRESULT getProperty(
        [in] BSTR strName,
        [out, retval] VARIANT * varValue);
    [id(DISPID_SAX_XMLREADER_PUTPROPERTY), helpstring("Set the value of a property.")]
    HRESULT putProperty(
        [in] BSTR strName,
        [in] VARIANT varValue);

    [propget, id(DISPID_SAX_XMLREADER_ENTITYRESOLVER), helpstring("Allow an application to register an entity resolver or look up the current entity resolver.")]
    HRESULT entityResolver(
        [out, retval] IVBSAXEntityResolver ** oResolver);
    [propputref, id(DISPID_SAX_XMLREADER_ENTITYRESOLVER), helpstring("Allow an application to register an entity resolver or look up the current entity resolver.")]
    HRESULT entityResolver(
        [in] IVBSAXEntityResolver * oResolver);

    [propget, id(DISPID_SAX_XMLREADER_CONTENTHANDLER), helpstring("Allow an application to register a content event handler or look up the current content event handler.")]
    HRESULT contentHandler(
        [out, retval] IVBSAXContentHandler ** oHandler);
    [propputref, id(DISPID_SAX_XMLREADER_CONTENTHANDLER), helpstring("Allow an application to register a content event handler or look up the current content event handler")]
    HRESULT contentHandler(
        [in] IVBSAXContentHandler * oHandler);

    [propget, id(DISPID_SAX_XMLREADER_DTDHANDLER), helpstring("Allow an application to register a DTD event handler or look up the current DTD event handler.")]
    HRESULT dtdHandler(
        [out, retval] IVBSAXDTDHandler ** oHandler);
    [propputref, id(DISPID_SAX_XMLREADER_DTDHANDLER), helpstring("Allow an application to register a DTD event handler or look up the current DTD event handler.")]
    HRESULT dtdHandler(
        [in] IVBSAXDTDHandler * oHandler);

    [propget, id(DISPID_SAX_XMLREADER_ERRORHANDLER), helpstring("Allow an application to register an error event handler or look up the current error event handler.")]
    HRESULT errorHandler(
        [out, retval] IVBSAXErrorHandler ** oHandler);
    [propputref, id(DISPID_SAX_XMLREADER_ERRORHANDLER), helpstring("Allow an application to register an error event handler or look up the current error event handler.")]
    HRESULT errorHandler(
        [in] IVBSAXErrorHandler * oHandler);

    [propget, id(DISPID_SAX_XMLREADER_BASEURL), helpstring("Set or get the base URL for the document.")]
    HRESULT baseURL(
        [out, retval] BSTR * strBaseURL);
    [propput, id(DISPID_SAX_XMLREADER_BASEURL), helpstring("Set or get the base URL for the document.")]
    HRESULT baseURL(
        [in] BSTR strBaseURL);

    [propget, id(DISPID_SAX_XMLREADER_SECUREBASEURL), helpstring("Set or get the secure base URL for the document.")]
    HRESULT secureBaseURL(
        [out, retval] BSTR * strSecureBaseURL);
    [propput, id(DISPID_SAX_XMLREADER_SECUREBASEURL), helpstring("Set or get the secure base URL for the document.")]
    HRESULT secureBaseURL(
        [in] BSTR strSecureBaseURL);

    [id(DISPID_SAX_XMLREADER_PARSE), helpstring("Parse an XML document.")]
    HRESULT parse(
        [in, optional] VARIANT varInput);
    [id(DISPID_SAX_XMLREADER_PARSEURL), helpstring("Parse an XML document from a system identifier (URI).")]
    HRESULT parseURL(
        [in] BSTR strURL);
};

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(1299eb1b-5b88-433e-82de-82ca75ad4e04), // IID_IVBSAXXMLFilter
    helpstring("IVBSAXXMLFilter interface"),
    pointer_default(unique)
]
interface IVBSAXXMLFilter : IDispatch
{
    [propget, id(DISPID_SAX_XMLFILTER_PARENT), helpstring("Set or get the parent reader")]
    HRESULT parent(
        [out, retval] IVBSAXXMLReader ** oReader);
    [propputref, id(DISPID_SAX_XMLFILTER_PARENT), helpstring("Set or get the parent reader")]
    HRESULT parent(
        [in] IVBSAXXMLReader * oReader);

};

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(796e7ac5-5aa2-4eff-acad-3faaf01a3288), // IID_IVBSAXLocator
    helpstring("IVBSAXLocator interface"),
    pointer_default(unique)
]
interface IVBSAXLocator : IDispatch
{   
    [propget, id(DISPID_SAX_LOCATOR_COLUMNNUMBER), helpstring("Get the column number where the current document event ends.")]
    HRESULT columnNumber(
        [out, retval] int * nColumn);

    [propget, id(DISPID_SAX_LOCATOR_LINENUMBER), helpstring("Get the line number where the current document event ends.")]
    HRESULT lineNumber(
        [out, retval] int * nLine);

    [propget, id(DISPID_SAX_LOCATOR_PUBLICID), helpstring("Get the public identifier for the current document event.")]
    HRESULT publicId(
        [out, retval] BSTR * strPublicId);

    [propget, id(DISPID_SAX_LOCATOR_SYSTEMID), helpstring("Get the system identifier for the current document event.")]
    HRESULT systemId(
        [out, retval] BSTR * strSystemId);
};

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(0c05d096-f45b-4aca-ad1a-aa0bc25518dc), // IID_IVBSAXEntityResolver
    helpstring("IVBSAXEntityResolver interface"),
    pointer_default(unique)
]
interface IVBSAXEntityResolver : IDispatch
{   
    [id(DISPID_SAX_ENTITYRESOLVER_RESOLVEENTITY), helpstring("Allow the application to resolve external entities.")]
    HRESULT resolveEntity(
        [in, out] BSTR * strPublicId,
        [in, out] BSTR * strSystemId,
        [out, retval] VARIANT * varInput);
};

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(2ed7290a-4dd5-4b46-bb26-4e4155e77faa), // IID_IVBSAXContentHandler
    helpstring("IVBSAXContentHandler interface"),
    pointer_default(unique)
]
interface IVBSAXContentHandler : IDispatch
{
    [propputref, id(DISPID_SAX_CONTENTHANDLER_DOCUMENTLOCATOR), helpstring("Receive an object for locating the origin of SAX document events.")]
    HRESULT documentLocator(
        [in] IVBSAXLocator * oLocator);

    [id(DISPID_SAX_CONTENTHANDLER_STARTDOCUMENT), helpstring("Receive notification of the beginning of a document.")]
    HRESULT startDocument();

    [id(DISPID_SAX_CONTENTHANDLER_ENDDOCUMENT), helpstring("Receive notification of the end of a document.")]
    HRESULT endDocument();

    [id(DISPID_SAX_CONTENTHANDLER_STARTPREFIXMAPPING), helpstring("Begin the scope of a prefix-URI Namespace mapping.")]
    HRESULT startPrefixMapping(
        [in, out] BSTR * strPrefix,
        [in, out] BSTR * strURI);

    [id(DISPID_SAX_CONTENTHANDLER_ENDPREFIXMAPPING), helpstring("End the scope of a prefix-URI mapping.")]
    HRESULT endPrefixMapping(
        [in, out] BSTR * strPrefix);

    [id(DISPID_SAX_CONTENTHANDLER_STARTELEMENT), helpstring("Receive notification of the beginning of an element.")]
    HRESULT startElement(
        [in, out] BSTR * strNamespaceURI, 
        [in, out] BSTR * strLocalName,
        [in, out] BSTR * strQName,
        [in] IVBSAXAttributes * oAttributes);

    [id(DISPID_SAX_CONTENTHANDLER_ENDELEMENT), helpstring("Receive notification of the end of an element.")]
    HRESULT endElement(
        [in, out] BSTR * strNamespaceURI,
        [in, out] BSTR * strLocalName,
        [in, out] BSTR * strQName);

    [id(DISPID_SAX_CONTENTHANDLER_CHARACTERS), helpstring("Receive notification of character data.")]
    HRESULT characters(
        [in, out] BSTR * strChars);

    [id(DISPID_SAX_CONTENTHANDLER_IGNORABLEWHITESPACE), helpstring("Receive notification of ignorable whitespace in element content.")]
    HRESULT ignorableWhitespace(
        [in, out] BSTR * strChars);

    [id(DISPID_SAX_CONTENTHANDLER_PROCESSINGINSTRUCTION), helpstring("Receive notification of a processing instruction.")]
    HRESULT processingInstruction(
        [in, out] BSTR * strTarget,
        [in, out] BSTR * strData);

    [id(DISPID_SAX_CONTENTHANDLER_SKIPPEDENTITY), helpstring("Receive notification of a skipped entity.")]
    HRESULT skippedEntity(
        [in, out] BSTR * strName);
};

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(24fb3297-302d-4620-ba39-3a732d850558), // IID_IVBSAXDTDHandler
    helpstring("IVBSAXDTDHandler interface"),
    pointer_default(unique)
]
interface IVBSAXDTDHandler : IDispatch
{   
    [id(DISPID_SAX_DTDHANDLER_NOTATIONDECL), helpstring("Receive notification of a notation declaration event.")]
    HRESULT notationDecl(
        [in, out] BSTR * strName,
        [in, out] BSTR * strPublicId,
        [in, out] BSTR * strSystemId);

    [id(DISPID_SAX_DTDHANDLER_UNPARSEDENTITYDECL), helpstring("Receive notification of an unparsed entity declaration event.")]
    HRESULT unparsedEntityDecl(
        [in, out] BSTR * strName,
        [in, out] BSTR * strPublicId,
        [in, out] BSTR * strSystemId,
        [in, out] BSTR * strNotationName);
};

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(d963d3fe-173c-4862-9095-b92f66995f52), // IID_IVBSAXErrorHandler
    helpstring("IVBSAXErrorHandler interface"),
    pointer_default(unique)
]
interface IVBSAXErrorHandler : IDispatch
{
    [id(DISPID_SAX_ERRORHANDLER_ERROR), helpstring("Receive notification of a recoverable error.")]
    HRESULT error(
        [in] IVBSAXLocator * oLocator, 
        [in, out] BSTR * strErrorMessage,
        [in] long nErrorCode);

    [id(DISPID_SAX_ERRORHANDLER_FATALERROR), helpstring("Receive notification of a non-recoverable error.")]
    HRESULT fatalError(
        [in] IVBSAXLocator * oLocator, 
        [in, out] BSTR * strErrorMessage,
        [in] long nErrorCode);

    [id(DISPID_SAX_ERRORHANDLER_IGNORABLEWARNING), helpstring("Receive notification of an ignorable warning.")]
    HRESULT ignorableWarning(
        [in] IVBSAXLocator * oLocator, 
        [in, out] BSTR * strErrorMessage,
        [in] long nErrorCode);
};

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(032aac35-8c0e-4d9d-979f-e3b702935576), // IID_IVBSAXLexicalHandler
    helpstring("IVBSAXLexicalHandler interface"),
    pointer_default(unique)
]
interface IVBSAXLexicalHandler : IDispatch 
{
    [id(DISPID_SAX_LEXICALHANDLER_STARTDTD), helpstring("Report the start of DTD declarations, if any.")]
    HRESULT startDTD(
        [in, out] BSTR * strName,
        [in, out] BSTR * strPublicId,
        [in, out] BSTR * strSystemId);
    [id(DISPID_SAX_LEXICALHANDLER_ENDDTD), helpstring("Report the end of DTD declarations.")]
    HRESULT endDTD();
    
    [id(DISPID_SAX_LEXICALHANDLER_STARTENTITY), helpstring("Report the beginning of some internal and external XML entities.")]
    HRESULT startEntity(
        [in, out] BSTR * strName);
    [id(DISPID_SAX_LEXICALHANDLER_ENDENTITY), helpstring("Report the end of an entity.")]
    HRESULT endEntity(
        [in, out] BSTR * strName);

    [id(DISPID_SAX_LEXICALHANDLER_STARTCDATA), helpstring("Report the start of a CDATA section.")]    
    HRESULT startCDATA();
    [id(DISPID_SAX_LEXICALHANDLER_ENDCDATA), helpstring("Report the end of a CDATA section.")]
    HRESULT endCDATA();

    [id(DISPID_SAX_LEXICALHANDLER_COMMENT), helpstring("Report an XML comment anywhere in the document.")]    
    HRESULT comment(
        [in, out] BSTR * strChars);
};

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(e8917260-7579-4be1-b5dd-7afbfa6f077b), // IID_IVBSAXDeclHandler
    helpstring("IVBSAXDeclHandler interface"),
    pointer_default(unique)
]
interface IVBSAXDeclHandler : IDispatch 
{
    [id(DISPID_SAX_DECLHANDLER_ELEMENTDECL), helpstring("Report an element type declaration.")]
    HRESULT elementDecl(
        [in, out] BSTR * strName,
        [in, out] BSTR * strModel);
    
    [id(DISPID_SAX_DECLHANDLER_ATTRIBUTEDECL), helpstring("Report an attribute type declaration.")]
    HRESULT attributeDecl(
        [in, out] BSTR * strElementName,
        [in, out] BSTR * strAttributeName,
        [in, out] BSTR * strType,
        [in, out] BSTR * strValueDefault,
        [in, out] BSTR * strValue);

    [id(DISPID_SAX_DECLHANDLER_INTERNALENTITYDECL), helpstring("Report an internal entity declaration.")]    
    HRESULT internalEntityDecl(
        [in, out] BSTR * strName,
        [in, out] BSTR * strValue);

    [id(DISPID_SAX_DECLHANDLER_EXTERNALENTITYDECL), helpstring("Report a parsed external entity declaration.")]
    HRESULT externalEntityDecl(
        [in, out] BSTR * strName,
        [in, out] BSTR * strPublicId,
        [in, out] BSTR * strSystemId);
};

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(10dc0586-132b-4cac-8bb3-db00ac8b7ee0), // IID_IVBSAXAttributes
    helpstring("IVBSAXAttributes interface"),
    pointer_default(unique)
]
interface IVBSAXAttributes : IDispatch
{   
    [propget, id(DISPID_SAX_ATTRIBUTES_LENGTH), helpstring("Get the number of attributes in the list.")]
    HRESULT length(
        [out, retval] int * nLength);

    [id(DISPID_SAX_ATTRIBUTES_GETURI), helpstring("Look up an attribute's Namespace URI by index.")]
    HRESULT getURI(
        [in] int nIndex,
        [out, retval] BSTR * strURI);

    [id(DISPID_SAX_ATTRIBUTES_GETLOCALNAME), helpstring("Look up an attribute's local name by index.")]
    HRESULT getLocalName(
        [in] int nIndex,
        [out, retval] BSTR * strLocalName);

    [id(DISPID_SAX_ATTRIBUTES_GETQNAME), helpstring("Look up an attribute's XML 1.0 qualified name by index.")]
    HRESULT getQName(
        [in] int nIndex,
        [out, retval] BSTR * strQName);

    [id(DISPID_SAX_ATTRIBUTES_GETINDEXFROMNAME), helpstring("Look up the index of an attribute by Namespace name.")]
    HRESULT getIndexFromName(
        [in] BSTR strURI,
        [in] BSTR strLocalName,
        [out, retval] int * nIndex);

    [id(DISPID_SAX_ATTRIBUTES_GETINDEXFROMQNAME), helpstring("Look up the index of an attribute by XML 1.0 qualified name.")]
    HRESULT getIndexFromQName(
        [in] BSTR strQName,
        [out, retval] int * nIndex);

    [id(DISPID_SAX_ATTRIBUTES_GETTYPE), helpstring("Look up an attribute's type by index.")]
    HRESULT getType(
        [in] int nIndex,
        [out, retval] BSTR * strType);

    [id(DISPID_SAX_ATTRIBUTES_GETTYPEFROMNAME), helpstring("Look up an attribute's type by Namespace name.")]
    HRESULT getTypeFromName(
        [in] BSTR strURI,
        [in] BSTR strLocalName,
        [out, retval] BSTR * strType);

    [id(DISPID_SAX_ATTRIBUTES_GETTYPEFROMQNAME), helpstring("Look up an attribute's type by XML 1.0 qualified name.")]
    HRESULT getTypeFromQName(
        [in] BSTR strQName,
        [out, retval] BSTR * strType);

    [id(DISPID_SAX_ATTRIBUTES_GETVALUE), helpstring("Look up an attribute's value by index.")]
    HRESULT getValue(
        [in] int nIndex,
        [out, retval] BSTR * strValue);

    [id(DISPID_SAX_ATTRIBUTES_GETVALUEFROMNAME), helpstring("Look up an attribute's value by Namespace name.")]
    HRESULT getValueFromName(
        [in] BSTR strURI,
        [in] BSTR strLocalName,
        [out, retval] BSTR * strValue);

    [id(DISPID_SAX_ATTRIBUTES_GETVALUEFROMQNAME), helpstring("Look up an attribute's value by XML 1.0 qualified name.")]
    HRESULT getValueFromQName(
        [in] BSTR strQName,
        [out, retval] BSTR * strValue);
};

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(4d7ff4ba-1565-4ea8-94e1-6e724a46f98d), // IID_IMXWriter
    helpstring("IMXWriter interface"),
    pointer_default(unique)
]
interface IMXWriter :  IDispatch 
{   
    [propput, id(DISPID_MX_WRITER_OUTPUT), helpstring("Set or get the output.")]
    HRESULT output (
        [in] VARIANT varDestination);
    [propget, id(DISPID_MX_WRITER_OUTPUT), helpstring("Set or get the output.")]
    HRESULT output (
        [out, retval] VARIANT * varDestination);

    [propput, id(DISPID_MX_WRITER_ENCODING), helpstring("Set or get the output encoding.")]
    HRESULT encoding (
        [in] BSTR strEncoding);
    [propget, id(DISPID_MX_WRITER_ENCODING), helpstring("Set or get the output encoding.")]
    HRESULT encoding (
        [out, retval] BSTR * strEncoding);

    [propput, id(DISPID_MX_WRITER_BYTEORDERMARK), helpstring("Determine whether or not to write the byte order mark")]
    HRESULT byteOrderMark (
        [in] VARIANT_BOOL fWriteByteOrderMark);
    [propget, id(DISPID_MX_WRITER_BYTEORDERMARK), helpstring("Determine whether or not to write the byte order mark")]
    HRESULT byteOrderMark (
        [out, retval] VARIANT_BOOL * fWriteByteOrderMark);

    [propput, id(DISPID_MX_WRITER_INDENT), helpstring("Enable or disable auto indent mode.")]
    HRESULT indent (
        [in] VARIANT_BOOL fIndentMode);
    [propget, id(DISPID_MX_WRITER_INDENT), helpstring("Enable or disable auto indent mode.")]
    HRESULT indent (
        [out, retval] VARIANT_BOOL * fIndentMode);

    [propput, id(DISPID_MX_WRITER_STANDALONE), helpstring("Set or get the standalone document declaration.")]
    HRESULT standalone (
        [in] VARIANT_BOOL fValue);
    [propget, id(DISPID_MX_WRITER_STANDALONE), helpstring("Set or get the standalone document declaration.")]
    HRESULT standalone (
        [out, retval] VARIANT_BOOL * fValue);

    [propput, id(DISPID_MX_WRITER_OMITXMLDECLARATION), helpstring("Determine whether or not to omit the XML declaration.")]
    HRESULT omitXMLDeclaration (
        [in] VARIANT_BOOL fValue);
    [propget, id(DISPID_MX_WRITER_OMITXMLDECLARATION), helpstring("Determine whether or not to omit the XML declaration.")]
    HRESULT omitXMLDeclaration (
        [out, retval] VARIANT_BOOL * fValue);

    [propput, id(DISPID_MX_WRITER_VERSION), helpstring("Set or get the xml version info.")]
    HRESULT version (
        [in] BSTR strVersion);
    [propget, id(DISPID_MX_WRITER_VERSION), helpstring("Set or get the xml version info.")]
    HRESULT version (
        [out, retval] BSTR * strVersion);

    [propput, id(DISPID_MX_WRITER_DISABLEOUTPUTESCAPING), helpstring("When enabled, the writer no longer escapes out its input when writing it out.")]
    HRESULT disableOutputEscaping(
        [in] VARIANT_BOOL fValue);
    [propget, id(DISPID_MX_WRITER_DISABLEOUTPUTESCAPING), helpstring("When enabled, the writer no longer escapes out its input when writing it out.")]
    HRESULT disableOutputEscaping(
        [out, retval] VARIANT_BOOL * fValue);    

    [id(DISPID_MX_WRITER_FLUSH), helpstring("Flushes all writer buffers forcing the writer to write to the underlying output object")]
    HRESULT flush();
};

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(f10d27cc-3ec0-415c-8ed8-77ab1c5e7262), // IID_IMXAttributes
    helpstring("IMXAttributes interface"),
    pointer_default(unique)
]
interface IMXAttributes : IDispatch
{
    [id(DISPID_MX_ATTRIBUTES_ADDATTRIBUTE), helpstring("Add an attribute to the end of the list.")]
    HRESULT addAttribute(
        [in] BSTR strURI,
        [in] BSTR strLocalName,
        [in] BSTR strQName,
        [in] BSTR strType,
        [in] BSTR strValue);    
    
    [id(DISPID_MX_ATTRIBUTES_ADDATTRIBUTEFROMINDEX), helpstring("Add an attribute, whose value is equal to the indexed attribute in the input attributes object, to the end of the list.")]
    HRESULT addAttributeFromIndex(
        [in] VARIANT varAtts,
        [in] int nIndex);

    [id(DISPID_MX_ATTRIBUTES_CLEAR), helpstring("Clear the attribute list for reuse.")]
    HRESULT clear();

    [id(DISPID_MX_ATTRIBUTES_REMOVEATTRIBUTE), helpstring("Remove an attribute from the list.")]
    HRESULT removeAttribute(
        [in] int nIndex); 
          
    [id(DISPID_MX_ATTRIBUTES_SETATTRIBUTE), helpstring("Set an attribute in the list.")]
    HRESULT setAttribute(
        [in] int nIndex,
        [in] BSTR strURI,
        [in] BSTR strLocalName,
        [in] BSTR strQName,
        [in] BSTR strType,
        [in] BSTR strValue);
 
    [id(DISPID_MX_ATTRIBUTES_SETATTRIBUTES), helpstring("Copy an entire Attributes object.")]
    HRESULT setAttributes(
        [in] VARIANT varAtts);
           
    [id(DISPID_MX_ATTRIBUTES_SETLOCALNAME), helpstring("Set the local name of a specific attribute.")]
    HRESULT setLocalName(
        [in] int nIndex, 
        [in] BSTR strLocalName);
           
    [id(DISPID_MX_ATTRIBUTES_SETQNAME), helpstring("Set the qualified name of a specific attribute.")]
    HRESULT setQName(
        [in] int nIndex, 
        [in] BSTR strQName);
           
    [id(DISPID_MX_ATTRIBUTES_SETTYPE), helpstring("Set the type of a specific attribute.")]
    HRESULT setType(
        [in] int nIndex, 
        [in] BSTR strType);
           
    [id(DISPID_MX_ATTRIBUTES_SETURI), helpstring("Set the Namespace URI of a specific attribute.")]
    HRESULT setURI(
        [in] int nIndex, 
        [in] BSTR strURI);
           
    [id(DISPID_MX_ATTRIBUTES_SETVALUE), helpstring("Set the value of a specific attribute.")]
    HRESULT setValue(
        [in] int nIndex, 
        [in] BSTR strValue);
};

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(808f4e35-8d5a-4fbe-8466-33a41279ed30), // IID_IMXReaderControl
    helpstring("IMXReaderControl interface"),
    pointer_default(unique)
]
interface IMXReaderControl : IDispatch
{
    [id(DISPID_MX_READER_CONTROL_ABORT), helpstring("Abort the reader")]
    HRESULT abort();

    [id(DISPID_MX_READER_CONTROL_RESUME), helpstring("Resume the reader")]
    HRESULT resume();

    [id(DISPID_MX_READER_CONTROL_SUSPEND), helpstring("Suspend the reader")]
    HRESULT suspend();
};

[
    object,
    local,
    odl, 
    dual,
    oleautomation,
    nonextensible,
    uuid(fa4bb38c-faf9-4cca-9302-d1dd0fe520db), // IID_IMXSchemaDeclHandler
    helpstring("IMXSchemaDeclHandler interface"),
    pointer_default(unique)
]
interface IMXSchemaDeclHandler : IDispatch
{   
    [id(DISPID_MX_SCHEMADECLHANDLER_SCHEMAELEMENTDECL), helpstring("Access schema element declaration")]
    HRESULT schemaElementDecl(
        [in] ISchemaElement * oSchemaElement);
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Namespace Manager
[
    local, object,
    uuid(c90352f4-643c-4fbc-bb23-e996eb2d51fd), // IID_IMXNamespacePrefixes
    helpstring("IMXNamespacePrefixes interface"),
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IMXNamespacePrefixes : IDispatch
{
    [propget, id(DISPID_VALUE)]                       HRESULT item([in]long index, [out,retval]BSTR* prefix);
    [propget, id(DISPID_MX_NSMGR_LENGTH)]             HRESULT length([out,retval]long* length);
    [propget, restricted, hidden, id(DISPID_NEWENUM)] HRESULT _newEnum([out,retval]IUnknown** ppUnk);
};

[
    local, object,
    uuid(c90352f5-643c-4fbc-bb23-e996eb2d51fd), // IID_IVBMXNamespaceManager
    helpstring("IVBMXNamespaceManager interface"),
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IVBMXNamespaceManager : IDispatch
{
    [propput, id(DISPID_MX_NSMGR_ALLOWOVERRIDE)]
    HRESULT allowOverride([in] VARIANT_BOOL fOverride);

    [propget, id(DISPID_MX_NSMGR_ALLOWOVERRIDE)]
    HRESULT allowOverride([out,retval] VARIANT_BOOL* fOverride);

    [id(DISPID_MX_NSMGR_RESET)]
    HRESULT reset();

    [id(DISPID_MX_NSMGR_PUSHCONTEXT)]
    HRESULT pushContext();

    [id(DISPID_MX_NSMGR_PUSHNODECONTEXT)]
    HRESULT pushNodeContext(
                    [in] IXMLDOMNode* contextNode,
                    [in, defaultvalue(-1)] VARIANT_BOOL fDeep);

    [id(DISPID_MX_NSMGR_POPCONTEXT)]
    HRESULT popContext();

    [id(DISPID_MX_NSMGR_DECLAREPREFIX)]
    HRESULT declarePrefix(
                    [in] BSTR prefix, 
                    [in] BSTR namespaceURI);

    [id(DISPID_MX_NSMGR_GETDECLAREDPREFIXES)]
    HRESULT getDeclaredPrefixes(
                    [out, retval] IMXNamespacePrefixes** prefixes);

    [id(DISPID_MX_NSMGR_GETPREFIXES)]
    HRESULT getPrefixes(
                    [in] BSTR namespaceURI, 
                    [out, retval] IMXNamespacePrefixes** prefixes);

    [id(DISPID_MX_NSMGR_GETURI)]
    HRESULT getURI(
                    [in] BSTR prefix, 
                    [out, retval] VARIANT* uri);

    [id(DISPID_MX_NSMGR_GETURIFROMNODE)]
    HRESULT getURIFromNode(
                    [in] BSTR strPrefix, 
                    [in] IXMLDOMNode* contextNode,
                    [out, retval] VARIANT* uri);
};

[
    hidden, 
    object,
    local,
    uuid(c90352f6-643c-4fbc-bb23-e996eb2d51fd), // IID_IMXNamespaceManager
    helpstring("IMXNamespaceManager interface"),
    pointer_default(unique)
]
interface IMXNamespaceManager : IUnknown
{
    HRESULT putAllowOverride([in] VARIANT_BOOL fOverride);

    HRESULT getAllowOverride([out,retval] VARIANT_BOOL* fOverride);

    HRESULT reset();

    HRESULT pushContext();

    HRESULT pushNodeContext(
                    [in] IXMLDOMNode* contextNode,
                    [in] VARIANT_BOOL fDeep);

    HRESULT popContext();

    HRESULT declarePrefix(
                    [in] LPCWSTR prefix,
                    [in] LPCWSTR namespaceURI);

    HRESULT getDeclaredPrefix(
                    [in] long nIndex, 
                    [in, out, annotation("_Out_writes_to_(*pcchPrefix, *pcchPrefix)")] wchar_t* pwchPrefix,
                    [in, out, annotation("_Inout_")] int* pcchPrefix);

    HRESULT getPrefix(
                    [in] LPCWSTR pwszNamespaceURI,
                    [in] long nIndex,
                    [in, out, annotation("_Out_writes_to_(*pcchPrefix, *pcchPrefix)")] wchar_t* pwchPrefix,
                    [in, out, annotation("_Inout_")] int* pcchPrefix);

    HRESULT getURI(
                    [in] LPCWSTR pwchPrefix,
                    [in] IXMLDOMNode* pContextNode,
                    [in, out, annotation("_Out_writes_to_(*pcchUri, *pcchUri)")] wchar_t* pwchUri, 
                    [in, out, annotation("_Inout_")] int* pcchUri);
};

[
    local, object,
    uuid(c90352f7-643c-4fbc-bb23-e996eb2d51fd), // IID_IMXXMLFilter
    helpstring("IMXXMLFilter interface"),
    odl, 
    dual,
    oleautomation,
    nonextensible,
    pointer_default(unique)
]
interface IMXXMLFilter : IDispatch
{
    [id(DISPID_MXXML_FILTER_GETFEATURE)]    HRESULT getFeature( [in] BSTR strName, [out, retval] VARIANT_BOOL * fValue);
    [id(DISPID_MXXML_FILTER_PUTFEATURE)]    HRESULT putFeature( [in] BSTR strName, [in] VARIANT_BOOL fValue);

    [id(DISPID_MXXML_FILTER_GETPROPERTY)]   HRESULT getProperty( [in] BSTR strName, [out, retval] VARIANT * varValue);
    [id(DISPID_MXXML_FILTER_PUTPROPERTY)]   HRESULT putProperty( [in] BSTR strName, [in] VARIANT varValue);

    [id(DISPID_MXXML_FILTER_ENTITYRESOLVER), propget]    HRESULT entityResolver( [out, retval] IUnknown ** oResolver);
    [id(DISPID_MXXML_FILTER_ENTITYRESOLVER), propputref] HRESULT entityResolver( [in] IUnknown * oResolver);
    [id(DISPID_MXXML_FILTER_CONTENTHANDLER), propget]    HRESULT contentHandler( [out, retval] IUnknown ** oHandler);
    [id(DISPID_MXXML_FILTER_CONTENTHANDLER), propputref] HRESULT contentHandler( [in] IUnknown * oHandler);
    [id(DISPID_MXXML_FILTER_DTDHANDLER), propget]        HRESULT dtdHandler( [out, retval] IUnknown ** oHandler);
    [id(DISPID_MXXML_FILTER_DTDHANDLER), propputref]     HRESULT dtdHandler( [in] IUnknown * oHandler);
    [id(DISPID_MXXML_FILTER_ERRORHANDLER), propget]      HRESULT errorHandler( [out, retval] IUnknown ** oHandler);
    [id(DISPID_MXXML_FILTER_ERRORHANDLER), propputref]   HRESULT errorHandler( [in] IUnknown * oHandler);
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Schema Object Model
cpp_quote("#if !defined(__msxml_som_enums__)")
cpp_quote("#define __msxml_som_enums__")
typedef [
    helpstring("Schema Object Model Item Types")
]
enum _SOMITEMTYPE
{
    SOMITEM_SCHEMA                      = 0x1000,
    SOMITEM_ATTRIBUTE                   = 0x1001,
    SOMITEM_ATTRIBUTEGROUP              = 0x1002,
    SOMITEM_NOTATION                    = 0x1003,
    SOMITEM_ANNOTATION                  = 0x1004,

    SOMITEM_IDENTITYCONSTRAINT          = 0x1100, // identity constraints
    SOMITEM_KEY                         = 0x1101,
    SOMITEM_KEYREF                      = 0x1102,
    SOMITEM_UNIQUE                      = 0x1103,

    SOMITEM_ANYTYPE                     = 0x2000, // Types
    SOMITEM_DATATYPE                    = 0x2100,
    SOMITEM_DATATYPE_ANYTYPE            = 0x2101,
    SOMITEM_DATATYPE_ANYURI             = 0x2102,
    SOMITEM_DATATYPE_BASE64BINARY       = 0x2103,
    SOMITEM_DATATYPE_BOOLEAN            = 0x2104,
    SOMITEM_DATATYPE_BYTE               = 0x2105,
    SOMITEM_DATATYPE_DATE               = 0x2106,
    SOMITEM_DATATYPE_DATETIME           = 0x2107, 
    SOMITEM_DATATYPE_DAY                = 0x2108,
    SOMITEM_DATATYPE_DECIMAL            = 0x2109,
    SOMITEM_DATATYPE_DOUBLE             = 0x210A,
    SOMITEM_DATATYPE_DURATION           = 0x210B, 
    SOMITEM_DATATYPE_ENTITIES           = 0x210C,
    SOMITEM_DATATYPE_ENTITY             = 0x210D,
    SOMITEM_DATATYPE_FLOAT              = 0x210E,
    SOMITEM_DATATYPE_HEXBINARY          = 0x210F,
    SOMITEM_DATATYPE_ID                 = 0x2110,
    SOMITEM_DATATYPE_IDREF              = 0x2111,
    SOMITEM_DATATYPE_IDREFS             = 0x2112,
    SOMITEM_DATATYPE_INT                = 0x2113,
    SOMITEM_DATATYPE_INTEGER            = 0x2114,
    SOMITEM_DATATYPE_LANGUAGE           = 0x2115,
    SOMITEM_DATATYPE_LONG               = 0x2116,
    SOMITEM_DATATYPE_MONTH              = 0x2117,
    SOMITEM_DATATYPE_MONTHDAY           = 0x2118, 
    SOMITEM_DATATYPE_NAME               = 0x2119,
    SOMITEM_DATATYPE_NCNAME             = 0x211A,
    SOMITEM_DATATYPE_NEGATIVEINTEGER    = 0x211B,
    SOMITEM_DATATYPE_NMTOKEN            = 0x211C,
    SOMITEM_DATATYPE_NMTOKENS           = 0x211D,
    SOMITEM_DATATYPE_NONNEGATIVEINTEGER = 0x211E,
    SOMITEM_DATATYPE_NONPOSITIVEINTEGER = 0x211F,
    SOMITEM_DATATYPE_NORMALIZEDSTRING   = 0x2120,
    SOMITEM_DATATYPE_NOTATION           = 0x2121,
    SOMITEM_DATATYPE_POSITIVEINTEGER    = 0x2122,
    SOMITEM_DATATYPE_QNAME              = 0x2123,
    SOMITEM_DATATYPE_SHORT              = 0x2124,
    SOMITEM_DATATYPE_STRING             = 0x2125,
    SOMITEM_DATATYPE_TIME               = 0x2126,
    SOMITEM_DATATYPE_TOKEN              = 0x2127,
    SOMITEM_DATATYPE_UNSIGNEDBYTE       = 0x2128,
    SOMITEM_DATATYPE_UNSIGNEDINT        = 0x2129,
    SOMITEM_DATATYPE_UNSIGNEDLONG       = 0x212A,
    SOMITEM_DATATYPE_UNSIGNEDSHORT      = 0x212B,
    SOMITEM_DATATYPE_YEAR               = 0x212C,
    SOMITEM_DATATYPE_YEARMONTH          = 0x212D,
    SOMITEM_DATATYPE_ANYSIMPLETYPE      = 0x21FF,

    SOMITEM_SIMPLETYPE                  = 0x2200,
    SOMITEM_COMPLEXTYPE                 = 0x2400,

    SOMITEM_PARTICLE                    = 0x4000, // particles
    SOMITEM_ANY                         = 0x4001,
    SOMITEM_ANYATTRIBUTE                = 0x4002,
    SOMITEM_ELEMENT                     = 0x4003,

    SOMITEM_GROUP                       = 0x4100, // groups : particles
    SOMITEM_ALL                         = 0x4101,
    SOMITEM_CHOICE                      = 0x4102,
    SOMITEM_SEQUENCE                    = 0x4103,
    SOMITEM_EMPTYPARTICLE               = 0x4104,

    SOMITEM_NULL                        = 0x0800, // null items
    SOMITEM_NULL_TYPE                   = 0x2800,
    SOMITEM_NULL_ANY                    = 0x4801, 
    SOMITEM_NULL_ANYATTRIBUTE           = 0x4802,
    SOMITEM_NULL_ELEMENT                = 0x4803,
} SOMITEMTYPE;

typedef [
    helpstring("Schema Object Model Attribute Uses")
]
enum _SCHEMAUSE
{
    SCHEMAUSE_OPTIONAL,    // 0
    SCHEMAUSE_PROHIBITED,  // 1
    SCHEMAUSE_REQUIRED,    // 2
} SCHEMAUSE;

typedef [
    helpstring("Schema Object Model Filters")
] enum _SCHEMADERIVATIONMETHOD
{
    SCHEMADERIVATIONMETHOD_EMPTY        = 0x0000,
    SCHEMADERIVATIONMETHOD_SUBSTITUTION = 0x0001,
    SCHEMADERIVATIONMETHOD_EXTENSION    = 0x0002,
    SCHEMADERIVATIONMETHOD_RESTRICTION  = 0x0004,
    SCHEMADERIVATIONMETHOD_LIST         = 0x0008,
    SCHEMADERIVATIONMETHOD_UNION        = 0x0010,
    SCHEMADERIVATIONMETHOD_ALL          = 0x00FF,
    SCHEMADERIVATIONMETHOD_NONE         = 0x0100,
} SCHEMADERIVATIONMETHOD;

typedef [
    helpstring("Schema Object Model Content Types")
] enum _SCHEMACONTENTTYPE
{
    SCHEMACONTENTTYPE_EMPTY,
    SCHEMACONTENTTYPE_TEXTONLY,
    SCHEMACONTENTTYPE_ELEMENTONLY,
    SCHEMACONTENTTYPE_MIXED,
} SCHEMACONTENTTYPE;

typedef [
    helpstring("Schema Object Model Process Contents")
] enum _SCHEMAPROCESSCONTENTS
{
    SCHEMAPROCESSCONTENTS_NONE,
    SCHEMAPROCESSCONTENTS_SKIP,
    SCHEMAPROCESSCONTENTS_LAX,
    SCHEMAPROCESSCONTENTS_STRICT,
} SCHEMAPROCESSCONTENTS;

typedef [
    helpstring("Schema Object Model Whitespace facet values")
] enum _SCHEMAWHITESPACE
{
    SCHEMAWHITESPACE_NONE       = -1,
    SCHEMAWHITESPACE_PRESERVE   =  0,
    SCHEMAWHITESPACE_REPLACE    =  1,
    SCHEMAWHITESPACE_COLLAPSE   =  2,
} SCHEMAWHITESPACE;


typedef [
    helpstring("Schema Object Model Type variety values")
] enum _SCHEMATYPEVARIETY
{
    SCHEMATYPEVARIETY_NONE      = -1,
    SCHEMATYPEVARIETY_ATOMIC    =  0,
    SCHEMATYPEVARIETY_LIST      =  1,
    SCHEMATYPEVARIETY_UNION     =  2,
}SCHEMATYPEVARIETY;
cpp_quote("#endif // !defined(__msxml_som_enums__)")

[
    local, object,
    uuid(50ea08b0-dd1b-4664-9a50-c2f40f4bd79a), // IID_IXMLDOMSchemaCollection2
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schemas Collection 2"),
    pointer_default(unique)
]
interface IXMLDOMSchemaCollection2 : IXMLDOMSchemaCollection
{
    [id(DISPID_SOM_VALIDATE)]       HRESULT validate();
    [id(DISPID_SOM_VALIDATEONLOAD), propput] HRESULT validateOnLoad([in]VARIANT_BOOL validateOnLoad);
    [id(DISPID_SOM_VALIDATEONLOAD), propget] HRESULT validateOnLoad([out,retval]VARIANT_BOOL* validateOnLoad);
    [id(DISPID_SOM_GETSCHEMA)]      HRESULT getSchema([in]BSTR namespaceURI, [out,retval]ISchema** schema);
    [id(DISPID_SOM_GETDECLARATION)] HRESULT getDeclaration([in]IXMLDOMNode* node, [out,retval]ISchemaItem** item);
};

[
    local, object,
    uuid(50ea08b1-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchemaStringCollection
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema String Collection"),
    pointer_default(unique)
]
interface ISchemaStringCollection : IDispatch 
{
    [id(DISPID_VALUE), propget]                       HRESULT item([in]long index, [out,retval]BSTR* bstr);
    [id(DISPID_SOM_LENGTH), propget]                  HRESULT length([out,retval]long* length);
    [id(DISPID_NEWENUM), hidden, restricted, propget] HRESULT _newEnum([out,retval]IUnknown** ppunk);
}; 

[
    local, object,
    uuid(50ea08b2-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchemaItemCollection
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema Item Collection"),
    pointer_default(unique)
]
interface ISchemaItemCollection : IDispatch 
{
    [id(DISPID_VALUE), propget]                       HRESULT item([in]long index, [out,retval]ISchemaItem** item);
    [id(DISPID_SOM_ITEMBYNAME)]                       HRESULT itemByName([in]BSTR name, [out,retval]ISchemaItem** item);
    [id(DISPID_SOM_ITEMBYQNAME)]                      HRESULT itemByQName([in]BSTR name, [in]BSTR namespaceURI, [out,retval]ISchemaItem** item);
    [id(DISPID_SOM_LENGTH), propget]                  HRESULT length([out,retval]long* length);
    [id(DISPID_NEWENUM), hidden, restricted, propget] HRESULT _newEnum([out,retval]IUnknown** ppunk);
};

[
    local, object,
    uuid(50ea08b3-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchemaItem
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema Item"),
    pointer_default(unique)
]
interface ISchemaItem : IDispatch 
{
    [id(DISPID_SOM_NAME), propget]           HRESULT name([out,retval]BSTR* name);
    [id(DISPID_SOM_NAMESPACEURI), propget]   HRESULT namespaceURI([out,retval]BSTR* namespaceURI);
    [id(DISPID_SOM_SCHEMA), propget]         HRESULT schema([out,retval]ISchema** schema);
    [id(DISPID_SOM_ID), propget]             HRESULT id([out,retval]BSTR* id);
    [id(DISPID_SOM_ITEMTYPE), propget]       HRESULT itemType([out,retval]SOMITEMTYPE* itemType);
    [id(DISPID_SOM_UNHANDLEDATTRS), propget] HRESULT unhandledAttributes([out,retval]IVBSAXAttributes** attributes);
    [id(DISPID_SOM_WRITEANNOTATION)]         HRESULT writeAnnotation([in]IUnknown* annotationSink, [out,retval]VARIANT_BOOL* isWritten);
}; 

[
    local, object,
    uuid(50ea08b4-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchema
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema"),
    pointer_default(unique)
]
interface ISchema : ISchemaItem 
{
    [id(DISPID_SOM_TARGETNAMESPACE), propget] HRESULT targetNamespace([out,retval]BSTR* targetNamespace);
    [id(DISPID_SOM_VERSION), propget]         HRESULT version([out,retval]BSTR* version);
    [id(DISPID_SOM_TYPES), propget]           HRESULT types([out,retval]ISchemaItemCollection** types);
    [id(DISPID_SOM_ELEMENTS), propget]        HRESULT elements([out,retval]ISchemaItemCollection** elements);
    [id(DISPID_SOM_ATTRIBUTES), propget]      HRESULT attributes([out,retval]ISchemaItemCollection** attributes);
    [id(DISPID_SOM_ATTRIBUTEGROUPS), propget] HRESULT attributeGroups([out,retval]ISchemaItemCollection** attributeGroups);
    [id(DISPID_SOM_MODELGROUPS), propget]     HRESULT modelGroups([out,retval]ISchemaItemCollection** modelGroups);
    [id(DISPID_SOM_NOTATIONS), propget]       HRESULT notations([out,retval]ISchemaItemCollection** notations);
    [id(DISPID_SOM_SCHEMALOCATIONS), propget] HRESULT schemaLocations([out,retval]ISchemaStringCollection** schemaLocations);
}; 

[
    local, object,
    uuid(50ea08b5-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchemaParticle
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema Particle"),
    pointer_default(unique)
]
interface ISchemaParticle : ISchemaItem
{
    [id(DISPID_SOM_MINOCCURS), propget] HRESULT minOccurs([out,retval]VARIANT* minOccurs);
    [id(DISPID_SOM_MAXOCCURS), propget] HRESULT maxOccurs([out,retval]VARIANT* maxOccurs);
}; 

[
    local, object,
    uuid(50ea08b6-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchemaAttribute
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema Attribute"),
    pointer_default(unique)
]
interface ISchemaAttribute : ISchemaItem 
{
    [id(DISPID_SOM_TYPE), propget]         HRESULT type([out,retval]ISchemaType** type);
    [id(DISPID_SOM_SCOPE), propget]        HRESULT scope([out,retval]ISchemaComplexType** scope);
    [id(DISPID_SOM_DEFAULTVALUE), propget] HRESULT defaultValue([out,retval]BSTR* defaultValue);
    [id(DISPID_SOM_FIXEDVALUE), propget]   HRESULT fixedValue([out,retval]BSTR* fixedValue);
    [id(DISPID_SOM_USE), propget]          HRESULT use([out,retval]SCHEMAUSE* use);
    [id(DISPID_SOM_ISREFERENCE), propget]  HRESULT isReference([out,retval]VARIANT_BOOL* reference);
}; 

[
    local, object,
    uuid(50ea08b7-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchemaElement
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema Element"),
    pointer_default(unique)
]
interface ISchemaElement : ISchemaParticle 
{
    [id(DISPID_SOM_TYPE), propget]              HRESULT type([out,retval]ISchemaType** type);
    [id(DISPID_SOM_SCOPE), propget]             HRESULT scope([out,retval]ISchemaComplexType** scope);
    [id(DISPID_SOM_DEFAULTVALUE), propget]      HRESULT defaultValue([out,retval]BSTR* defaultValue);
    [id(DISPID_SOM_FIXEDVALUE), propget]        HRESULT fixedValue([out,retval]BSTR* fixedValue);
    [id(DISPID_SOM_ISNILLABLE), propget]        HRESULT isNillable([out,retval]VARIANT_BOOL* nillable);
    [id(DISPID_SOM_IDCONSTRAINTS), propget]     HRESULT identityConstraints([out,retval]ISchemaItemCollection** constraints);
    [id(DISPID_SOM_SUBSTITUTIONGROUP), propget] HRESULT substitutionGroup([out,retval]ISchemaElement** element);
    [id(DISPID_SOM_EXCLUSIONS), propget]        HRESULT substitutionGroupExclusions([out,retval]SCHEMADERIVATIONMETHOD* exclusions);
    [id(DISPID_SOM_DISALLOWED), propget]        HRESULT disallowedSubstitutions([out,retval]SCHEMADERIVATIONMETHOD* disallowed);
    [id(DISPID_SOM_ISABSTRACT), propget]        HRESULT isAbstract([out,retval]VARIANT_BOOL* abstract);
    [id(DISPID_SOM_ISREFERENCE), propget]       HRESULT isReference([out,retval]VARIANT_BOOL* reference);
}; 

[
    local, object,
    uuid(50ea08b8-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchemaType
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema Type"),
    pointer_default(unique)
]
interface ISchemaType : ISchemaItem 
{
    [id(DISPID_SOM_BASETYPES), propget]      HRESULT baseTypes([out,retval]ISchemaItemCollection** baseTypes);
    [id(DISPID_SOM_FINAL), propget]          HRESULT final([out,retval]SCHEMADERIVATIONMETHOD* final);
    [id(DISPID_SOM_VARIETY), propget]        HRESULT variety([out,retval]SCHEMATYPEVARIETY* variety);
    [id(DISPID_SOM_DERIVEDBY), propget]      HRESULT derivedBy([out,retval]SCHEMADERIVATIONMETHOD* derivedBy);
    [id(DISPID_SOM_ISVALID)]                 HRESULT isValid([in]BSTR data, [out,retval]VARIANT_BOOL* valid);
    // Facets 
    [id(DISPID_SOM_MINEXCLUSIVE), propget]   HRESULT minExclusive([out,retval]BSTR* minExclusive);
    [id(DISPID_SOM_MININCLUSIVE), propget]   HRESULT minInclusive([out,retval]BSTR* minInclusive);
    [id(DISPID_SOM_MAXEXCLUSIVE), propget]   HRESULT maxExclusive([out,retval]BSTR* maxExclusive);
    [id(DISPID_SOM_MAXINCLUSIVE), propget]   HRESULT maxInclusive([out,retval]BSTR* maxInclusive);
    [id(DISPID_SOM_TOTALDIGITS), propget]    HRESULT totalDigits([out,retval]VARIANT* totalDigits);
    [id(DISPID_SOM_FRACTIONDIGITS), propget] HRESULT fractionDigits([out,retval]VARIANT* fractionDigits);
    [id(DISPID_SOM_LENGTH), propget]         HRESULT length([out,retval]VARIANT* length);
    [id(DISPID_SOM_MINLENGTH), propget]      HRESULT minLength([out,retval]VARIANT* minLength);
    [id(DISPID_SOM_MAXLENGTH), propget]      HRESULT maxLength([out,retval]VARIANT* maxLength);
    [id(DISPID_SOM_ENUMERATION), propget]    HRESULT enumeration([out,retval]ISchemaStringCollection** enumeration);
    [id(DISPID_SOM_WHITESPACE), propget]     HRESULT whitespace([out,retval]SCHEMAWHITESPACE* whitespace);
    [id(DISPID_SOM_PATTERNS), propget]       HRESULT patterns([out,retval]ISchemaStringCollection** patterns);
}; 

[
    local, object,
    uuid(50ea08b9-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchemaComplexType
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema Complex Type"),
    pointer_default(unique)
]
interface ISchemaComplexType : ISchemaType 
{
    [id(DISPID_SOM_ISABSTRACT), propget]   HRESULT isAbstract([out,retval]VARIANT_BOOL* abstract);
    [id(DISPID_SOM_ANYATTRIBUTE), propget] HRESULT anyAttribute([out,retval]ISchemaAny** anyAttribute);
    [id(DISPID_SOM_ATTRIBUTES), propget]   HRESULT attributes([out,retval]ISchemaItemCollection** attributes);
    [id(DISPID_SOM_CONTENTTYPE), propget]  HRESULT contentType([out,retval]SCHEMACONTENTTYPE* contentType);
    [id(DISPID_SOM_CONTENTMODEL), propget] HRESULT contentModel([out,retval]ISchemaModelGroup** contentModel);
    [id(DISPID_SOM_PROHIBITED), propget]   HRESULT prohibitedSubstitutions([out,retval]SCHEMADERIVATIONMETHOD* prohibited);
}; 

[
    local, object,
    uuid(50ea08ba-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchemaAttributeGroup
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema Attribute Group"),
    pointer_default(unique)
]
interface ISchemaAttributeGroup : ISchemaItem 
{
    [id(DISPID_SOM_ANYATTRIBUTE), propget]    HRESULT anyAttribute([out,retval]ISchemaAny** anyAttribute);
    [id(DISPID_SOM_ATTRIBUTES), propget]      HRESULT attributes([out,retval]ISchemaItemCollection** attributes);
}; 

[
    local, object,
    uuid(50ea08bb-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchemaModelGroup
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema Type"),
    pointer_default(unique)
]
interface ISchemaModelGroup : ISchemaParticle 
{
    [id(DISPID_SOM_PARTICLES), propget] HRESULT particles([out,retval]ISchemaItemCollection** particles);
}; 

[
    local, object,
    uuid(50ea08bc-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchemaAny
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema Any"),
    pointer_default(unique)
]
interface ISchemaAny : ISchemaParticle 
{
    [id(DISPID_SOM_NAMESPACES), propget]      HRESULT namespaces([out,retval]ISchemaStringCollection** namespaces);
    [id(DISPID_SOM_PROCESSCONTENTS), propget] HRESULT processContents([out,retval]SCHEMAPROCESSCONTENTS* processContents);
}; 

[
    local, object,
    uuid(50ea08bd-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchemaIdentityConstraint
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema Any"),
    pointer_default(unique)
]
interface ISchemaIdentityConstraint : ISchemaItem 
{
    [id(DISPID_SOM_SELECTOR), propget]      HRESULT selector([out,retval]BSTR* selector);
    [id(DISPID_SOM_FIELDS), propget]        HRESULT fields([out,retval]ISchemaStringCollection** fields);
    [id(DISPID_SOM_REFERENCEDKEY), propget] HRESULT referencedKey([out,retval]ISchemaIdentityConstraint** key);
}; 

[
    local, object,
    uuid(50ea08be-dd1b-4664-9a50-c2f40f4bd79a), // IID_ISchemaNotation
    odl, 
    dual,
    oleautomation,
    nonextensible,
    helpstring("XML Schema Notation"),
    pointer_default(unique)
]
interface ISchemaNotation : ISchemaItem 
{
    [id(DISPID_SOM_SYSTEMIDENTIFIER), propget] HRESULT systemIdentifier([out,retval]BSTR* uri);
    [id(DISPID_SOM_PUBLICIDENTIFIER), propget] HRESULT publicIdentifier([out,retval]BSTR* uri);
}; 

//+-------------------------------------------------------------------------
//
// IE4 Interfaces
//
//--------------------------------------------------------------------------


#ifndef IMPORTED_MSXML
[
    local, object,
    uuid(65725580-9B5D-11d0-9BFE-00C04FC99C8E), // IID_IXMLElementCollection
    odl, 
    dual,
    oleautomation,
    hidden, // replaced by IDOMNodeList
    helpstring("IXMLElementCollection helps to enumerate through a XML document tree.")
]
interface IXMLElementCollection : IDispatch
{
    [propput, restricted, hidden, id(DISPID_XMLELEMENTCOLLECTION_LENGTH)] HRESULT length([in] long v);
    [propget, id(DISPID_XMLELEMENTCOLLECTION_LENGTH), helpstring("get number of elements in this IXMLElementCollection.")] HRESULT length([retval, out] long * p);
    [propget, restricted, hidden, id(DISPID_XMLELEMENTCOLLECTION_NEWENUM)] HRESULT _newEnum([retval, out] IUnknown ** ppUnk);
    [id(DISPID_XMLELEMENTCOLLECTION_ITEM), helpstring("get current item, or (optional) by index and name.")] HRESULT item([optional, in] VARIANT var1,[optional, in] VARIANT var2,[retval, out] IDispatch ** ppDisp);
};

[
    local, object,
    uuid(F52E2B61-18A1-11d1-B105-00805F49916B), // IID_IXMLDocument
    odl, 
    dual,
    oleautomation,
    hidden, // replaced by IDOMDocument 
    helpstring("IXMLDocument loads and saves XML document. This is obsolete. You should use IDOMDocument or IXMLDOMDocument.")
]
interface IXMLDocument : IDispatch
{
    [propget, id(DISPID_XMLDOCUMENT_ROOT), helpstring("get root IXMLElement of the XML document.")] HRESULT root ([retval, out] IXMLElement * * p);
    [propget, restricted, hidden, id(DISPID_XMLDOCUMENT_FILESIZE)] HRESULT fileSize([retval, out] BSTR * p);
    [propget, restricted, hidden, id(DISPID_XMLDOCUMENT_FILEMODIFIEDDATE)] HRESULT fileModifiedDate([retval, out] BSTR * p);
    [propget, restricted, hidden, id(DISPID_XMLDOCUMENT_FILEUPDATEDDATE)] HRESULT fileUpdatedDate([retval, out] BSTR * p);
    [propget, id(DISPID_XMLDOCUMENT_URL), helpstring("set URL to load an XML document from the URL.")] HRESULT URL([retval, out] BSTR * p);
    [propput, id(DISPID_XMLDOCUMENT_URL), helpstring("get url.")] HRESULT URL([in] BSTR p);
    [propget, restricted, hidden, id(DISPID_XMLDOCUMENT_MIMETYPE)] HRESULT mimeType([retval, out] BSTR * p);
    [propget, id(DISPID_XMLDOCUMENT_READYSTATE), helpstring("get ready state.")] HRESULT readyState([retval, out]long *pl);
    [propget, id(DISPID_XMLDOCUMENT_CHARSET), helpstring("get encoding.")]  HRESULT charset([retval, out]BSTR *p);
    [propput, id(DISPID_XMLDOCUMENT_CHARSET), helpstring("set encoding.")]  HRESULT charset([in]BSTR p);
    [propget, id(DISPID_XMLDOCUMENT_VERSION), helpstring("get XML version number.")]  HRESULT version([retval, out]BSTR *p);
    [propget, id(DISPID_XMLDOCUMENT_DOCTYPE), helpstring("get document type.")]  HRESULT doctype([retval, out]BSTR *p);
    [propget, restricted, hidden, id(DISPID_XMLDOCUMENT_DTDURL)]   HRESULT dtdURL([retval, out]BSTR *p);
    [id(DISPID_XMLDOCUMENT_CREATEELEMENT), helpstring("create different types of IXMLElements.")] HRESULT createElement([in] VARIANT vType, [optional, in] VARIANT var1, [retval, out] IXMLElement * * ppElem);
};
#endif

[
    local, object,
    uuid(2B8DE2FE-8D2D-11d1-B2FC-00C04FD915A9), // IID_IXMLDocument2
    hidden  // Because that this interface is the default interface of coclass XMLDocument
]
interface IXMLDocument2 : IDispatch
{
    [propget, id(DISPID_XMLDOCUMENT_ROOT), helpstring("get root IXMLElement of the XML document.")] HRESULT root ([retval, out] IXMLElement2 * * p);
    [propget, restricted, hidden, id(DISPID_XMLDOCUMENT_FILESIZE)] HRESULT fileSize([retval, out] BSTR * p);
    [propget, restricted, hidden, id(DISPID_XMLDOCUMENT_FILEMODIFIEDDATE)] HRESULT fileModifiedDate([retval, out] BSTR * p);
    [propget, restricted, hidden, id(DISPID_XMLDOCUMENT_FILEUPDATEDDATE)] HRESULT fileUpdatedDate([retval, out] BSTR * p);
    [propget, id(DISPID_XMLDOCUMENT_URL), helpstring("set URL to load an XML document from the URL.")] HRESULT URL([retval, out] BSTR * p);
    [propput, id(DISPID_XMLDOCUMENT_URL), helpstring("get url.")] HRESULT URL([in] BSTR p);
    [propget, restricted, hidden, id(DISPID_XMLDOCUMENT_MIMETYPE)] HRESULT mimeType([retval, out] BSTR * p);
    [propget, id(DISPID_XMLDOCUMENT_READYSTATE), helpstring("get ready state.")] HRESULT readyState([retval, out]long *pl);
    [propget, id(DISPID_XMLDOCUMENT_CHARSET), helpstring("get encoding.")]  HRESULT charset([retval, out]BSTR *p);
    [propput, id(DISPID_XMLDOCUMENT_CHARSET), helpstring("set encoding.")]  HRESULT charset([in]BSTR p);
    [propget, id(DISPID_XMLDOCUMENT_VERSION), helpstring("get XML version number.")]  HRESULT version([retval, out]BSTR *p);
    [propget, id(DISPID_XMLDOCUMENT_DOCTYPE), helpstring("get document type.")]  HRESULT doctype([retval, out]BSTR *p);
    [propget, restricted, hidden, id(DISPID_XMLDOCUMENT_DTDURL)]   HRESULT dtdURL([retval, out]BSTR *p);
    [id(DISPID_XMLDOCUMENT_CREATEELEMENT), helpstring("create different types of IXMLElements.")] HRESULT createElement([in] VARIANT vType, [optional, in] VARIANT var1, [retval, out] IXMLElement2 * * ppElem);
    [propget, id(DISPID_XMLDOCUMENT_ASYNC), helpstring("get asynchronous loading flag.")] HRESULT async([retval, out] VARIANT_BOOL * pf);
    [propput, id(DISPID_XMLDOCUMENT_ASYNC), helpstring("set flag to turn on/off asynchronous loading.")] HRESULT async([in] VARIANT_BOOL f);
};

#ifndef IMPORTED_MSXML
[
    local, object,
    uuid(3F7F31AC-E15F-11d0-9C25-00C04FC99C8E), // IID_IXMLElement
    odl, 
    dual,
    oleautomation,
    hidden, // replaced by IDOMNode
    helpstring("IXMLElement represents an element in the XML document tree.")
]
interface IXMLElement : IDispatch
{
    [propget, id(DISPID_XMLELEMENT_TAGNAME), helpstring("get tag name.")] HRESULT tagName([retval, out] BSTR * p);
    [propput, id(DISPID_XMLELEMENT_TAGNAME), helpstring("set tag name.")] HRESULT tagName([in] BSTR p);
    [propget, id(DISPID_XMLELEMENT_PARENT), helpstring("get parent IXMLElement.")] HRESULT parent([retval, out]IXMLElement **ppParent);
    [id(DISPID_XMLELEMENT_SETATTRIBUTE), helpstring("set attribute.")] HRESULT setAttribute([in] BSTR strPropertyName,[in] VARIANT PropertyValue);
    [id(DISPID_XMLELEMENT_GETATTRIBUTE), helpstring("get attribute.")] HRESULT getAttribute([in] BSTR strPropertyName,[retval, out] VARIANT* PropertyValue);
    [id(DISPID_XMLELEMENT_REMOVEATTRIBUTE), helpstring("remove attribute.")] HRESULT removeAttribute([in] BSTR strPropertyName);
    [propget, id(DISPID_XMLELEMENT_CHILDREN), helpstring("get a IXMLElementCollection of children.")] HRESULT children([retval, out] IXMLElementCollection * * pp);
    [propget, id(DISPID_XMLELEMENT_TYPE), helpstring("get type of this IXMLElement.")] HRESULT type([retval, out] long *plType);
    [propget, id(DISPID_XMLELEMENT_TEXT), helpstring("get text.")] HRESULT text([retval, out] BSTR *p);
    [propput, id(DISPID_XMLELEMENT_TEXT), helpstring("set text.")] HRESULT text([in] BSTR p);
    [id(DISPID_XMLELEMENT_ADDCHILD), helpstring("add a child.")] HRESULT addChild([in] IXMLElement *pChildElem, long lIndex, long lReserved); // lReserved must be -1
    [id(DISPID_XMLELEMENT_REMOVECHILD), helpstring("remove a child.")] HRESULT removeChild([in]IXMLElement *pChildElem);
}
#endif

[
    local, object,
    uuid(2B8DE2FF-8D2D-11d1-B2FC-00C04FD915A9), // IID_IXMLElement2
    odl, 
    dual,
    oleautomation,
    hidden, // replaced by IDOMNode
    helpstring("IXMLElement2 extends IXMLElement.")
]
interface IXMLElement2 : IDispatch
{
    [propget, id(DISPID_XMLELEMENT_TAGNAME), helpstring("get tag name.")] HRESULT tagName([retval, out] BSTR * p);
    [propput, id(DISPID_XMLELEMENT_TAGNAME), helpstring("set tag name.")] HRESULT tagName([in] BSTR p);
    [propget, id(DISPID_XMLELEMENT_PARENT), helpstring("get parent IXMLElement.")] HRESULT parent([retval, out]IXMLElement2 **ppParent);
    [id(DISPID_XMLELEMENT_SETATTRIBUTE), helpstring("set attribute.")] HRESULT setAttribute([in] BSTR strPropertyName,[in] VARIANT PropertyValue);
    [id(DISPID_XMLELEMENT_GETATTRIBUTE), helpstring("get attribute.")] HRESULT getAttribute([in] BSTR strPropertyName,[retval, out] VARIANT* PropertyValue);
    [id(DISPID_XMLELEMENT_REMOVEATTRIBUTE), helpstring("remove attribute.")] HRESULT removeAttribute([in] BSTR strPropertyName);
    [propget, id(DISPID_XMLELEMENT_CHILDREN), helpstring("get a IXMLElementCollection of all children.")] HRESULT children([retval, out] IXMLElementCollection * * pp);
    [propget, id(DISPID_XMLELEMENT_TYPE), helpstring("get type of this IXMLElement.")] HRESULT type([retval, out] long *plType);
    [propget, id(DISPID_XMLELEMENT_TEXT), helpstring("get text.")] HRESULT text([retval, out] BSTR *p);
    [propput, id(DISPID_XMLELEMENT_TEXT), helpstring("set text.")] HRESULT text([in] BSTR p);
    [id(DISPID_XMLELEMENT_ADDCHILD), helpstring("add a child.")] HRESULT addChild([in] IXMLElement2 *pChildElem, long lIndex, long lReserved); // lReserved must be -1
    [id(DISPID_XMLELEMENT_REMOVECHILD), helpstring("remove a child.")] HRESULT removeChild([in]IXMLElement2 *pChildElem);
    [propget, id(DISPID_XMLELEMENT_ATTRIBUTES), helpstring("get a IXMLElementCollection of all attributes.")] HRESULT attributes([retval, out] IXMLElementCollection ** pp); 
};

[
    local, object,
    uuid(D4D4A0FC-3B73-11d1-B2B4-00C04FB92596), // IID_IXMLAttribute
    odl, 
    dual,
    oleautomation,
    hidden, // replaced by IDOMNode
    helpstring("IXMLAttribute allows to get attributes of an IXMLElement.")
]
interface IXMLAttribute : IDispatch
{
    [propget, id(DISPID_XMLATTRIBUTE_NAME), helpstring("get attribute name.")] HRESULT name([retval, out] BSTR* n);
    [propget, id(DISPID_XMLATTRIBUTE_VALUE), helpstring("get attribute value.")] HRESULT value([retval, out] BSTR* v);
};

#ifndef IMPORTED_MSXML
[
    local, object,
    uuid(948C5AD3-C58D-11d0-9C0B-00C04FC99C8E), // IID_IXMLError
    odl, 
    hidden, // this is not scriptable.
    helpstring("Gets error info.")
]
interface IXMLError : IUnknown
{
    HRESULT GetErrorInfo(XML_ERROR *pErrorReturn);
}
#endif

//+-------------------------------------------------------------------------
//
//  CoClasses
//
//--------------------------------------------------------------------------


// DOM Document rental-model co-Class, version independent
[
    uuid(F6D90F11-9C73-11D3-B32E-00C04F990BB4), // CLSID_DOMDocument
    helpstring("W3C-DOM XML Document (Apartment)")
]
coclass DOMDocument
{
    [default] interface IXMLDOMDocument2;
    [default, source] dispinterface XMLDOMDocumentEvents;
};

// DOM Document rental-model co-Class, 2.6 version dependent
[
    uuid(f5078f1b-c551-11d3-89b9-0000f81fe221), // CLSID_DOMDocument26
    helpstring("W3C-DOM XML Document (Apartment)")
]
coclass DOMDocument26
{
    [default] interface IXMLDOMDocument2;
    [default, source] dispinterface XMLDOMDocumentEvents;
};

// DOM Document rental-model co-Class, 3.0 version dependent
[
    uuid(f5078f32-c551-11d3-89b9-0000f81fe221), // CLSID_DOMDocument30
    helpstring("W3C-DOM XML Document (Apartment)")
]
coclass DOMDocument30
{
    [default] interface IXMLDOMDocument2;
    [default, source] dispinterface XMLDOMDocumentEvents;
};


// DOM Document free-threaded co-Class, version independent
[
    uuid(F6D90F12-9C73-11D3-B32E-00C04F990BB4), // CLSID_FreeThreadedDOMDocument
    helpstring("W3C-DOM XML Document (Free threaded)")
]
coclass FreeThreadedDOMDocument
{
    [default] interface IXMLDOMDocument2;
    [default, source] dispinterface XMLDOMDocumentEvents;
};

// DOM Document free-threaded co-Class, 2.6 version dependent
[
    uuid(f5078f1c-c551-11d3-89b9-0000f81fe221), // CLSID_FreeThreadedDOMDocument26
    helpstring("W3C-DOM XML Document (Free threaded)")
]
coclass FreeThreadedDOMDocument26
{
    [default] interface IXMLDOMDocument2;
    [default, source] dispinterface XMLDOMDocumentEvents;
};

// DOM Document free-threaded co-Class, 3.0 version dependent
[
    uuid(f5078f33-c551-11d3-89b9-0000f81fe221), // CLSID_FreeThreadedDOMDocument30
    helpstring("W3C-DOM XML Document (Free threaded)")
]
coclass FreeThreadedDOMDocument30
{
    [default] interface IXMLDOMDocument2;
    [default, source] dispinterface XMLDOMDocumentEvents;
};

// XML Schema Cache, version independent
[
    uuid(373984c9-b845-449b-91e7-45ac83036ade),
    helpstring("XML Schema Cache")
]
coclass XMLSchemaCache
{
    [default] interface IXMLDOMSchemaCollection;
};

// XML Schema Cache, version 2.6 dependent
[
    uuid(f5078f1d-c551-11d3-89b9-0000f81fe221),
    helpstring("XML Schema Cache 2.6")
]
coclass XMLSchemaCache26
{
    [default] interface IXMLDOMSchemaCollection;
};

// XML Schema Cache, version 3.0 dependent
[
    uuid(f5078f34-c551-11d3-89b9-0000f81fe221),
    helpstring("XML Schema Cache 3.0")
]
coclass XMLSchemaCache30
{
    [default] interface IXMLDOMSchemaCollection;
};

// XSLTemplate, version independent
[
    uuid(2933BF94-7B36-11d2-B20E-00C04F983E60), // CLSID_XMLDOMXSLTemplate (Progid=Msxml2.XMLDOMXSLTemplate)
    helpstring("Compiled XSL Stylesheet Cache")
]
coclass XSLTemplate
{
    [default] interface IXSLTemplate;
};

// XSLTemplate, 2.6 version dependent
[
    uuid(f5078f21-c551-11d3-89b9-0000f81fe221), // CLSID_XMLDOMXSLTemplate (Progid=Microsoft.XMLDOMXSLTemplate)
    helpstring("Compiled XSL Stylesheet Cache 2.6")
]
coclass XSLTemplate26
{
    [default] interface IXSLTemplate;
};

// XSLTemplate, 3.0 version dependent
[
    uuid(f5078f36-c551-11d3-89b9-0000f81fe221), // CLSID_XMLDOMXSLTemplate30 (Progid=Msxml2.XMLDOMXSLTemplate.3.0)
    helpstring("Compiled XSL Stylesheet Cache 3.0")
]
coclass XSLTemplate30
{
    [default] interface IXSLTemplate;
};


// XMLDSO, version independent
[
    uuid(F6D90F14-9C73-11D3-B32E-00C04F990BB4),
    helpstring("XML Data Source Object")
]
coclass DSOControl
{
    [default] interface IDSOControl;
};

// DSOControl, 2.6 version dependent
[
    uuid(f5078f1f-c551-11d3-89b9-0000f81fe221),
    helpstring("XML Data Source Object")
]
coclass DSOControl26
{
    [default] interface IDSOControl;
};

// DSOControl, 3.0 version dependent
[
    uuid(f5078f39-c551-11d3-89b9-0000f81fe221),
    helpstring("XML Data Source Object")
]
coclass DSOControl30
{
    [default] interface IDSOControl;
};

// XML HTTP Request Class, version independent
[
    uuid(F6D90F16-9C73-11D3-B32E-00C04F990BB4), // CLSID_XMLHTTP
    helpstring("XML HTTP Request class.")
]
coclass XMLHTTP
{
    [default] interface IXMLHTTPRequest;
};

// XML HTTP Request Class, 2.6, version dependent
[
    uuid(f5078f1e-c551-11d3-89b9-0000f81fe221), // CLSID_XMLHTTP26
    helpstring("XML HTTP Request class.")
]
coclass XMLHTTP26
{
    [default] interface IXMLHTTPRequest;
};

// XML HTTP Request Class, 3.0, version dependent
[
    uuid(f5078f35-c551-11d3-89b9-0000f81fe221), // CLSID_XMLHTTP30
    helpstring("XML HTTP Request class.")
]
coclass XMLHTTP30
{
    [default] interface IXMLHTTPRequest;
};

// Server XML HTTP Request Class, version independent
[
    uuid(afba6b42-5692-48ea-8141-dc517dcf0ef1), // CLSID_ServerXMLHTTP
    helpstring("Server XML HTTP Request class.")
]
coclass ServerXMLHTTP
{
    [default] interface IServerXMLHTTPRequest;
}

// Server XML HTTP Request Class, 3.0, version dependent
[
    uuid(afb40ffd-b609-40a3-9828-f88bbe11e4e3), // CLSID_ServerXMLHTTP30
    helpstring("Server XML HTTP Request class.")
]
coclass ServerXMLHTTP30
{
    [default] interface IServerXMLHTTPRequest;
}

// SAXXMLReader co-class, version independent
[
    uuid(079aa557-4a18-424a-8eee-e39f0a8d41b9), // CLSID_SAXXMLReader
    helpstring("SAX XML Reader (version independent) coclass")
]
coclass SAXXMLReader
{
    [default] interface IVBSAXXMLReader;
    interface ISAXXMLReader;
    interface IMXReaderControl;
};

// SAXXMLReader co-class, 3.0 version dependent
[
    uuid(3124c396-fb13-4836-a6ad-1317f1713688), // CLSID_SAXXMLReader30
    helpstring("SAX XML Reader 3.0 coclass")
]
coclass SAXXMLReader30
{
    [default] interface IVBSAXXMLReader;
    interface ISAXXMLReader;
    interface IMXReaderControl;
};

// MXXMLWriter co-class, version independent
[
    uuid(fc220ad8-a72a-4ee8-926e-0b7ad152a020), // CLSID_MXXMLWriter
    helpstring("Microsoft XML Writer (version independent) coclass")
]
coclass MXXMLWriter
{
    [default] interface IMXWriter;

    interface ISAXContentHandler;
    interface ISAXErrorHandler;
    interface ISAXDTDHandler;
    interface ISAXLexicalHandler;
    interface ISAXDeclHandler;

    interface IVBSAXContentHandler;    
    interface IVBSAXDeclHandler;
    interface IVBSAXDTDHandler;
    interface IVBSAXErrorHandler;
    interface IVBSAXLexicalHandler;
};

// MXXMLWriter co-class, 3.0 version dependent
[
    uuid(3d813dfe-6c91-4a4e-8f41-04346a841d9c), // CLSID_MXXMLWriter30
    helpstring("Microsoft XML Writer 3.0 coclass")
]
coclass MXXMLWriter30
{
    [default] interface IMXWriter;

    interface ISAXContentHandler;    
    interface ISAXDeclHandler;
    interface ISAXDTDHandler;
    interface ISAXErrorHandler;
    interface ISAXLexicalHandler;

    interface IVBSAXContentHandler;    
    interface IVBSAXDeclHandler;
    interface IVBSAXDTDHandler;
    interface IVBSAXErrorHandler;
    interface IVBSAXLexicalHandler;
};

// MXHTMLWriter co-class, version independent
[
    uuid(a4c23ec3-6b70-4466-9127-550077239978), // CLSID_MXHTMLWriter
    helpstring("Microsoft HTML Writer (version independent) coclass")
]
coclass MXHTMLWriter
{
    [default] interface IMXWriter;

    interface ISAXContentHandler;
    interface ISAXErrorHandler;
    interface ISAXDTDHandler;
    interface ISAXLexicalHandler;
    interface ISAXDeclHandler;

    interface IVBSAXContentHandler;    
    interface IVBSAXDeclHandler;
    interface IVBSAXDTDHandler;
    interface IVBSAXErrorHandler;
    interface IVBSAXLexicalHandler;
};

// MXHTMLWriter co-class, 3.0 version dependent
[
    uuid(853d1540-c1a7-4aa9-a226-4d3bd301146d), // CLSID_MXHTMLWriter30
    helpstring("Microsoft HTML Writer 3.0 coclass")
]
coclass MXHTMLWriter30
{
    [default] interface IMXWriter;

    interface ISAXContentHandler;    
    interface ISAXDeclHandler;
    interface ISAXDTDHandler;
    interface ISAXErrorHandler;
    interface ISAXLexicalHandler;

    interface IVBSAXContentHandler;    
    interface IVBSAXDeclHandler;
    interface IVBSAXDTDHandler;
    interface IVBSAXErrorHandler;
    interface IVBSAXLexicalHandler;
};

// SAXAttributes co-class, version independent
[
    uuid(4dd441ad-526d-4a77-9f1b-9841ed802fb0), // CLSID_SAXAttributes
    helpstring("SAX Attributes (version independent) coclass")
]
coclass SAXAttributes
{
    [default] interface IMXAttributes;
    interface IVBSAXAttributes;    
    interface ISAXAttributes;
};

// SAXAttributes co-class, 3.0 version dependent
[
    uuid(3e784a01-f3ae-4dc0-9354-9526b9370eba), // CLSID_SAXAttributes30
    helpstring("SAX Attributes 3.0 coclass")
]
coclass SAXAttributes30
{
    [default] interface IMXAttributes;
    interface IVBSAXAttributes;    
    interface ISAXAttributes;
};


// MXNamespaceManager co-class version independent
[
    uuid(88d969d5-f192-11d4-a65f-0040963251e5), // CLSID_MXNamespaceManager
    helpstring("MX Namespace Manager coclass")
]
coclass MXNamespaceManager
{
    [default] interface IVBMXNamespaceManager;
    interface IMXNamespaceManager;
};

#ifndef IMPORTED_MSXML
// XML Document Class, IE4 version
[
    uuid(CFC399AF-D876-11d0-9C10-00C04FC99C8E), // CLSID_XMLDocument
    helpstring("XMLDocument extends IXML Document.  It is obsolete.  You should use DOMDocument.  This object should not be confused with the XMLDocument property on the XML data island."),
    hidden // replaced by DOMDocument 
]
coclass XMLDocument
{
    [default] interface IXMLDocument2;
}
#endif

}

cpp_quote("//----------------------------")
cpp_quote("// MSXML SPECIFIC ERROR CODES ")
cpp_quote("//----------------------------")
cpp_quote("#define E_XML_NOTWF                0xC00CE223L  // Validate failed because the document is not well formed.")
cpp_quote("#define E_XML_NODTD                0xC00CE224L  // The node is neither Valid nor Invalid because no DTD/Schema declaration was found.")
cpp_quote("#define E_XML_INVALID              0xC00CE225L  // Validate failed because of a DTD/Schema violation.")
cpp_quote("#define E_XML_BUFFERTOOSMALL       0xC00CE226L  // Buffer passed in is too small to receive the data.")


cpp_quote("#ifdef __USE_MSXML2_NAMESPACE__")
cpp_quote("}")
cpp_quote("#endif")


cpp_quote("#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */")
#pragma endregion
