Microsoft.Search.Query.xsd.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Microsoft.Search.Query.Schemas {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.IO;
    using System.Linq;
    using System.Diagnostics;
    using System.Xml;
    using System.Xml.Schema;
    using System.Xml.Linq;
    using Xml.Schema.Linq;
    
    
    /// <summary>
    /// <para>
    /// Regular expression: (Query)
    /// </para>
    /// </summary>
    public partial class QueryPacket : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static QueryPacket Load(string xmlFile) {
            return XTypedServices.Load<QueryPacket>(xmlFile);
        }
        
        public static QueryPacket Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<QueryPacket>(xmlFile);
        }
        
        public static QueryPacket Parse(string xml) {
            return XTypedServices.Parse<QueryPacket>(xml);
        }
        
        public static explicit operator QueryPacket(XElement xe) { return XTypedServices.ToXTypedElement<QueryPacket>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<QueryPacket>(this);
        }
    
        /// <summary>
        /// <para>
        /// Regular expression: (Query)
        /// </para>
        /// </summary>
        public QueryPacket() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName QueryXName = System.Xml.Linq.XName.Get("Query", "urn:Microsoft.Search.Query");
    
        /// <summary>
        /// <para>
        /// Occurrence: required
        /// </para>
        /// <para>
        /// Regular expression: (Query)
        /// </para>
        /// </summary>
        public virtual QueryLocalType Query {
            get {                
                XElement x = this.GetElement(QueryXName);
                return ((QueryLocalType)(x));
            }
            set {
                this.SetElement(QueryXName, value);
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName revisionXName = System.Xml.Linq.XName.Get("revision", "");
    
        /// <summary>
        /// <para>
        /// Occurrence: optional
        /// </para>
        /// </summary>
        public virtual System.Int32? revision {
            get {
                XAttribute x = this.Attribute(revisionXName);
                if ((x == null)) {
                    return null;
                }
                return XTypedServices.ParseValue<int>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype);
            }
            set {
                this.SetAttribute(revisionXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype);
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName buildXName = System.Xml.Linq.XName.Get("build", "");
    
        /// <summary>
        /// <para>
        /// Occurrence: optional
        /// </para>
        /// </summary>
        public virtual string build {
            get {
                XAttribute x = this.Attribute(buildXName);
                if ((x == null)) {
                    return null;
                }
                return XTypedServices.ParseValue<string>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
            set {
                this.SetAttribute(buildXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("QueryPacket", "urn:Microsoft.Search.Query");
    
        static QueryPacket() {
            BuildElementDictionary();
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static Dictionary<System.Xml.Linq.XName, System.Type> localElementDictionary = new Dictionary<System.Xml.Linq.XName, System.Type>();
        
        private static void BuildElementDictionary() {
            localElementDictionary.Add(QueryXName, typeof(QueryLocalType));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        Dictionary<System.Xml.Linq.XName, System.Type> IXMetaData.LocalElementsDictionary {
            get {
                return localElementDictionary;
            }
        }
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    
        /// <summary>
        /// <para>
        /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
        /// </para>
        /// </summary>
        public partial class QueryLocalType : XTypedElement, IXMetaData {
            
            public static explicit operator QueryLocalType(XElement xe) { return XTypedServices.ToXTypedElement<QueryLocalType>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
            
            public override XTypedElement Clone() {
                return XTypedServices.CloneXTypedElement<QueryLocalType>(this);
            }
        
            /// <summary>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public QueryLocalType() {
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName QueryIdXName = System.Xml.Linq.XName.Get("QueryId", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// If this element is present, it must be returned in the response from the Query Web service.
            /// </para>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual QueryId QueryId {
                get {                
                    XElement x = this.GetElement(QueryIdXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((QueryId)(x));
                }
                set {
                    this.SetElement(QueryIdXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName ContextXName = System.Xml.Linq.XName.Get("Context", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual Context Context {
                get {                
                    XElement x = this.GetElement(ContextXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((Context)(x));
                }
                set {
                    this.SetElement(ContextXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName RangeXName = System.Xml.Linq.XName.Get("Range", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual Range Range {
                get {                
                    XElement x = this.GetElement(RangeXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((Range)(x));
                }
                set {
                    this.SetElement(RangeXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName PropertiesXName = System.Xml.Linq.XName.Get("Properties", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual Properties Properties {
                get {                
                    XElement x = this.GetElement(PropertiesXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((Properties)(x));
                }
                set {
                    this.SetElement(PropertiesXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName SortByPropertiesXName = System.Xml.Linq.XName.Get("SortByProperties", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// If no managed properties are specified for sorting results, by default the results will be sorted by Rank.
            /// </para>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual SortByProperties SortByProperties {
                get {                
                    XElement x = this.GetElement(SortByPropertiesXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((SortByProperties)(x));
                }
                set {
                    this.SetElement(SortByPropertiesXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName ImplicitAndBehaviorXName = System.Xml.Linq.XName.Get("ImplicitAndBehavior", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// This element applies to the Query Web method, and only when using the Keyword Query Syntax Reference. The only format that is supported is the Microsoft.Search.Response.Document format.
            /// </para>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual ImplicitAndBehavior ImplicitAndBehavior {
                get {                
                    XElement x = this.GetElement(ImplicitAndBehaviorXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((ImplicitAndBehavior)(x));
                }
                set {
                    this.SetElement(ImplicitAndBehaviorXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName RelevanceModelXName = System.Xml.Linq.XName.Get("RelevanceModel", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual RelevanceModel RelevanceModel {
                get {                
                    XElement x = this.GetElement(RelevanceModelXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((RelevanceModel)(x));
                }
                set {
                    this.SetElement(RelevanceModelXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName EnableStemmingXName = System.Xml.Linq.XName.Get("EnableStemming", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// When using the FAST Query Language, it is also possible to control stemming more precisely inside the query string.
            /// </para>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual EnableStemming EnableStemming {
                get {                
                    XElement x = this.GetElement(EnableStemmingXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((EnableStemming)(x));
                }
                set {
                    this.SetElement(EnableStemmingXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName TrimDuplicatesXName = System.Xml.Linq.XName.Get("TrimDuplicates", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// For FAST Search Server 2010 for SharePoint, this element can also be used to collapse hits in the result set by using a group identifier (ID).
            ///
            ///The attributes apply only to FAST Search Server 2010 for SharePoint.
            /// </para>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual TrimDuplicates TrimDuplicates {
                get {                
                    XElement x = this.GetElement(TrimDuplicatesXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((TrimDuplicates)(x));
                }
                set {
                    this.SetElement(TrimDuplicatesXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName IncludeSpecialTermResultsXName = System.Xml.Linq.XName.Get("IncludeSpecialTermResults", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// For FAST Search Server 2010 for SharePoint, special term results includes best bets and Visual best bets.
            /// </para>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual IncludeSpecialTermResults IncludeSpecialTermResults {
                get {                
                    XElement x = this.GetElement(IncludeSpecialTermResultsXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((IncludeSpecialTermResults)(x));
                }
                set {
                    this.SetElement(IncludeSpecialTermResultsXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName PreQuerySuggestionsXName = System.Xml.Linq.XName.Get("PreQuerySuggestions", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual PreQuerySuggestions PreQuerySuggestions {
                get {                
                    XElement x = this.GetElement(PreQuerySuggestionsXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((PreQuerySuggestions)(x));
                }
                set {
                    this.SetElement(PreQuerySuggestionsXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName HighlightQuerySuggestionsXName = System.Xml.Linq.XName.Get("HighlightQuerySuggestions", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual HighlightQuerySuggestions HighlightQuerySuggestions {
                get {                
                    XElement x = this.GetElement(HighlightQuerySuggestionsXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((HighlightQuerySuggestions)(x));
                }
                set {
                    this.SetElement(HighlightQuerySuggestionsXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName CapitalizeFirstLettersXName = System.Xml.Linq.XName.Get("CapitalizeFirstLetters", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual CapitalizeFirstLetters CapitalizeFirstLetters {
                get {                
                    XElement x = this.GetElement(CapitalizeFirstLettersXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((CapitalizeFirstLetters)(x));
                }
                set {
                    this.SetElement(CapitalizeFirstLettersXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName ResultProviderXName = System.Xml.Linq.XName.Get("ResultProvider", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// NOTE: For People Search queries, specify SharePointSearch as the result provider even when FAST Search Server 2010 for SharePoint is the search back-end.
            /// </para>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual Microsoft.Search.Query.Schemas.ResultProvider ResultProvider {
                get {                
                    XElement x = this.GetElement(ResultProviderXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((Microsoft.Search.Query.Schemas.ResultProvider)(x));
                }
                set {
                    this.SetElement(ResultProviderXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName ResubmitFlagsXName = System.Xml.Linq.XName.Get("ResubmitFlags", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual ResubmitFlags ResubmitFlags {
                get {                
                    XElement x = this.GetElement(ResubmitFlagsXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((ResubmitFlags)(x));
                }
                set {
                    this.SetElement(ResubmitFlagsXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName EnableSpellcheckXName = System.Xml.Linq.XName.Get("EnableSpellcheck", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// The element value specifies the spelling correction mode to apply to the query.
            /// </para>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual Microsoft.Search.Query.Schemas.EnableSpellcheck EnableSpellcheck {
                get {                
                    XElement x = this.GetElement(EnableSpellcheckXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((Microsoft.Search.Query.Schemas.EnableSpellcheck)(x));
                }
                set {
                    this.SetElement(EnableSpellcheckXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName UserContextXName = System.Xml.Linq.XName.Get("UserContext", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// The keyword management search settings can be restricted to context. A context defines when a search setting should apply, typically targeting a specific group of users.
            /// </para>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual UserContext UserContext {
                get {                
                    XElement x = this.GetElement(UserContextXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((UserContext)(x));
                }
                set {
                    this.SetElement(UserContextXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName FindSimilarXName = System.Xml.Linq.XName.Get("FindSimilar", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// The find similar features enable you to search for documents that are similar to already retrieved query results. The similarity evaluation is based on a statistical measure.
            /// </para>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual FindSimilar FindSimilar {
                get {                
                    XElement x = this.GetElement(FindSimilarXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((FindSimilar)(x));
                }
                set {
                    this.SetElement(FindSimilarXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName IncludeRefinementResultsXName = System.Xml.Linq.XName.Get("IncludeRefinementResults", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual IncludeRefinementResults IncludeRefinementResults {
                get {                
                    XElement x = this.GetElement(IncludeRefinementResultsXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((IncludeRefinementResults)(x));
                }
                set {
                    this.SetElement(IncludeRefinementResultsXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName RefinementFiltersXName = System.Xml.Linq.XName.Get("RefinementFilters", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual RefinementFilters RefinementFilters {
                get {                
                    XElement x = this.GetElement(RefinementFiltersXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((RefinementFilters)(x));
                }
                set {
                    this.SetElement(RefinementFiltersXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName IgnoreAllNoiseQueryXName = System.Xml.Linq.XName.Get("IgnoreAllNoiseQuery", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual IgnoreAllNoiseQuery IgnoreAllNoiseQuery {
                get {                
                    XElement x = this.GetElement(IgnoreAllNoiseQueryXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((IgnoreAllNoiseQuery)(x));
                }
                set {
                    this.SetElement(IgnoreAllNoiseQueryXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName IncludeRelevantResultsXName = System.Xml.Linq.XName.Get("IncludeRelevantResults", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual IncludeRelevantResults IncludeRelevantResults {
                get {                
                    XElement x = this.GetElement(IncludeRelevantResultsXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((IncludeRelevantResults)(x));
                }
                set {
                    this.SetElement(IncludeRelevantResultsXName, value);
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected internal static readonly System.Xml.Linq.XName IncludeHighConfidenceResultsXName = System.Xml.Linq.XName.Get("IncludeHighConfidenceResults", "urn:Microsoft.Search.Query");
        
            /// <summary>
            /// <para>
            /// Occurrence: optional
            /// </para>
            /// <para>
            /// Regular expression: (QueryId?, Context?, Range?, Properties?, SortByProperties?, ImplicitAndBehavior?, RelevanceModel?, EnableStemming?, TrimDuplicates?, IncludeSpecialTermResults?, PreQuerySuggestions?, HighlightQuerySuggestions?, CapitalizeFirstLetters?, ResultProvider?, ResubmitFlags?, EnableSpellcheck?, UserContext?, FindSimilar?, IncludeRefinementResults?, RefinementFilters?, IgnoreAllNoiseQuery?, IncludeRelevantResults?, IncludeHighConfidenceResults?)
            /// </para>
            /// </summary>
            public virtual IncludeHighConfidenceResults IncludeHighConfidenceResults {
                get {                
                    XElement x = this.GetElement(IncludeHighConfidenceResultsXName);
                    if ((x == null)) {
                        return null;
                    }
                    return ((IncludeHighConfidenceResults)(x));
                }
                set {
                    this.SetElement(IncludeHighConfidenceResultsXName, value);
                }
            }
        
            private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Query", "urn:Microsoft.Search.Query");
        
            static QueryLocalType() {
                BuildElementDictionary();
                contentModel = new SequenceContentModelEntity(new NamedContentModelEntity(QueryIdXName), new NamedContentModelEntity(ContextXName), new NamedContentModelEntity(RangeXName), new NamedContentModelEntity(PropertiesXName), new NamedContentModelEntity(SortByPropertiesXName), new NamedContentModelEntity(ImplicitAndBehaviorXName), new NamedContentModelEntity(RelevanceModelXName), new NamedContentModelEntity(EnableStemmingXName), new NamedContentModelEntity(TrimDuplicatesXName), new NamedContentModelEntity(IncludeSpecialTermResultsXName), new NamedContentModelEntity(PreQuerySuggestionsXName), new NamedContentModelEntity(HighlightQuerySuggestionsXName), new NamedContentModelEntity(CapitalizeFirstLettersXName), new NamedContentModelEntity(ResultProviderXName), new NamedContentModelEntity(ResubmitFlagsXName), new NamedContentModelEntity(EnableSpellcheckXName), new NamedContentModelEntity(UserContextXName), new NamedContentModelEntity(FindSimilarXName), new NamedContentModelEntity(IncludeRefinementResultsXName), new NamedContentModelEntity(RefinementFiltersXName), new NamedContentModelEntity(IgnoreAllNoiseQueryXName), new NamedContentModelEntity(IncludeRelevantResultsXName), new NamedContentModelEntity(IncludeHighConfidenceResultsXName));
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            private static Dictionary<System.Xml.Linq.XName, System.Type> localElementDictionary = new Dictionary<System.Xml.Linq.XName, System.Type>();
            
            private static void BuildElementDictionary() {
                localElementDictionary.Add(QueryIdXName, typeof(QueryId));
                localElementDictionary.Add(ContextXName, typeof(Context));
                localElementDictionary.Add(RangeXName, typeof(Range));
                localElementDictionary.Add(PropertiesXName, typeof(Properties));
                localElementDictionary.Add(SortByPropertiesXName, typeof(SortByProperties));
                localElementDictionary.Add(ImplicitAndBehaviorXName, typeof(ImplicitAndBehavior));
                localElementDictionary.Add(RelevanceModelXName, typeof(RelevanceModel));
                localElementDictionary.Add(EnableStemmingXName, typeof(EnableStemming));
                localElementDictionary.Add(TrimDuplicatesXName, typeof(TrimDuplicates));
                localElementDictionary.Add(IncludeSpecialTermResultsXName, typeof(IncludeSpecialTermResults));
                localElementDictionary.Add(PreQuerySuggestionsXName, typeof(PreQuerySuggestions));
                localElementDictionary.Add(HighlightQuerySuggestionsXName, typeof(HighlightQuerySuggestions));
                localElementDictionary.Add(CapitalizeFirstLettersXName, typeof(CapitalizeFirstLetters));
                localElementDictionary.Add(ResultProviderXName, typeof(ResultProvider));
                localElementDictionary.Add(ResubmitFlagsXName, typeof(ResubmitFlags));
                localElementDictionary.Add(EnableSpellcheckXName, typeof(EnableSpellcheck));
                localElementDictionary.Add(UserContextXName, typeof(UserContext));
                localElementDictionary.Add(FindSimilarXName, typeof(FindSimilar));
                localElementDictionary.Add(IncludeRefinementResultsXName, typeof(IncludeRefinementResults));
                localElementDictionary.Add(RefinementFiltersXName, typeof(RefinementFilters));
                localElementDictionary.Add(IgnoreAllNoiseQueryXName, typeof(IgnoreAllNoiseQuery));
                localElementDictionary.Add(IncludeRelevantResultsXName, typeof(IncludeRelevantResults));
                localElementDictionary.Add(IncludeHighConfidenceResultsXName, typeof(IncludeHighConfidenceResults));
            }
            
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            Dictionary<System.Xml.Linq.XName, System.Type> IXMetaData.LocalElementsDictionary {
                get {
                    return localElementDictionary;
                }
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            private static ContentModelEntity contentModel;
            
            ContentModelEntity IXMetaData.GetContentModel() {
                return contentModel;
            }
            
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            System.Xml.Linq.XName IXMetaData.SchemaName {
                get {
                    return xName;
                }
            }
            
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            SchemaOrigin IXMetaData.TypeOrigin {
                get {
                    return SchemaOrigin.Fragment;
                }
            }
            
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            ILinqToXsdTypeManager IXMetaData.TypeManager {
                get {
                    return LinqToXsdTypeManager.Instance;
                }
            }
        }
    }
    
    public partial class QueryId : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static QueryId Load(string xmlFile) {
            return XTypedServices.Load<QueryId>(xmlFile);
        }
        
        public static QueryId Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<QueryId>(xmlFile);
        }
        
        public static QueryId Parse(string xml) {
            return XTypedServices.Parse<QueryId>(xml);
        }
        
        public static explicit operator QueryId(XElement xe) { return XTypedServices.ToXTypedElement<QueryId>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<QueryId>(this);
        }
    
        public QueryId() {
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("QueryId", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// Regular expression: (QueryText)
    /// </para>
    /// </summary>
    public partial class Context : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static Context Load(string xmlFile) {
            return XTypedServices.Load<Context>(xmlFile);
        }
        
        public static Context Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<Context>(xmlFile);
        }
        
        public static Context Parse(string xml) {
            return XTypedServices.Parse<Context>(xml);
        }
        
        public static explicit operator Context(XElement xe) { return XTypedServices.ToXTypedElement<Context>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<Context>(this);
        }
    
        /// <summary>
        /// <para>
        /// Regular expression: (QueryText)
        /// </para>
        /// </summary>
        public Context() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName QueryTextXName = System.Xml.Linq.XName.Get("QueryText", "urn:Microsoft.Search.Query");
    
        /// <summary>
        /// <para>
        /// Occurrence: required
        /// </para>
        /// <para>
        /// Regular expression: (QueryText)
        /// </para>
        /// </summary>
        public virtual QueryText QueryText {
            get {                
                XElement x = this.GetElement(QueryTextXName);
                return ((QueryText)(x));
            }
            set {
                this.SetElement(QueryTextXName, value);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Context", "urn:Microsoft.Search.Query");
    
        static Context() {
            BuildElementDictionary();
            contentModel = new SequenceContentModelEntity(new NamedContentModelEntity(QueryTextXName));
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static Dictionary<System.Xml.Linq.XName, System.Type> localElementDictionary = new Dictionary<System.Xml.Linq.XName, System.Type>();
        
        private static void BuildElementDictionary() {
            localElementDictionary.Add(QueryTextXName, typeof(QueryText));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        Dictionary<System.Xml.Linq.XName, System.Type> IXMetaData.LocalElementsDictionary {
            get {
                return localElementDictionary;
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static ContentModelEntity contentModel;
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return contentModel;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class QueryText : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static QueryText Load(string xmlFile) {
            return XTypedServices.Load<QueryText>(xmlFile);
        }
        
        public static QueryText Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<QueryText>(xmlFile);
        }
        
        public static QueryText Parse(string xml) {
            return XTypedServices.Parse<QueryText>(xml);
        }
        
        public static explicit operator QueryText(XElement xe) { return XTypedServices.ToXTypedElement<QueryText>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<QueryText>(this);
        }
    
        public QueryText() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual string TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<string>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
        }
    
        public enum TypeEnum {
        
            STRING,
        
            MSSQLFT,
        
            FQL,
        }
        
        public sealed class TypeEnumValidator {
        
            private TypeEnumValidator() {
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), new Xml.Schema.Linq.RestrictionFacets(((Xml.Schema.Linq.RestrictionFlags)(16)), new object[] {
                "STRING",
                "MSSQLFT",
                "FQL"}, 0, 0, null, null, 0, null, null, 0, null, 0, XmlSchemaWhiteSpace.Preserve));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName typeXName = System.Xml.Linq.XName.Get("type", "");
        
        /// <summary>
        /// <para>
        /// Identifies the query type (see the following type Attribute table).
        /// </para>
        /// <para>
        /// Occurrence: optional
        /// </para>
        /// </summary>
        public virtual Microsoft.Search.Query.Schemas.QueryText.TypeEnum? type {
            get {
                XAttribute x = this.Attribute(typeXName);
                if ((x == null)) {
                    return null;
                }
                return ((Microsoft.Search.Query.Schemas.QueryText.TypeEnum)(Enum.Parse(typeof(Microsoft.Search.Query.Schemas.QueryText.TypeEnum), XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype, TypeEnumValidator.TypeDefinition))));
            }
            set {
                if (value == null) {
                    this.SetAttribute(typeXName, null, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
                }
                else {
                    this.SetAttributeWithValidation(typeXName, value.ToString(), "type", TypeEnumValidator.TypeDefinition);    
                }
            }    
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName languageXName = System.Xml.Linq.XName.Get("language", "");
    
        /// <summary>
        /// <para>
        /// Identifies the language of the keyword search. The value type is xml:lang. If specified, this is interpreted by SharePoint Enterprise Search as the query locale. If not specified, the default value is the language of the site.
        ///
        ///For more information about query processing related to the query locale for FAST Search Server 2010 for SharePoint, see Linguistic Query Features (FAST Search Server 2010 for SharePoint).
        /// </para>
        /// <para>
        /// Occurrence: optional
        /// </para>
        /// </summary>
        public virtual string language {
            get {
                XAttribute x = this.Attribute(languageXName);
                if ((x == null)) {
                    return null;
                }
                return XTypedServices.ParseValue<string>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Language).Datatype);
            }
            set {
                this.SetAttribute(languageXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Language).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("QueryText", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// Regular expression: (StartAt, Count)
    /// </para>
    /// </summary>
    public partial class Range : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static Range Load(string xmlFile) {
            return XTypedServices.Load<Range>(xmlFile);
        }
        
        public static Range Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<Range>(xmlFile);
        }
        
        public static Range Parse(string xml) {
            return XTypedServices.Parse<Range>(xml);
        }
        
        public static explicit operator Range(XElement xe) { return XTypedServices.ToXTypedElement<Range>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<Range>(this);
        }
    
        /// <summary>
        /// <para>
        /// Regular expression: (StartAt, Count)
        /// </para>
        /// </summary>
        public Range() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName StartAtXName = System.Xml.Linq.XName.Get("StartAt", "urn:Microsoft.Search.Query");
    
        /// <summary>
        /// <para>
        /// Occurrence: required
        /// </para>
        /// <para>
        /// Regular expression: (StartAt, Count)
        /// </para>
        /// </summary>
        public virtual StartAt StartAt {
            get {                
                XElement x = this.GetElement(StartAtXName);
                return ((StartAt)(x));
            }
            set {
                this.SetElement(StartAtXName, value);
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName CountXName = System.Xml.Linq.XName.Get("Count", "urn:Microsoft.Search.Query");
    
        /// <summary>
        /// <para>
        /// Occurrence: required
        /// </para>
        /// <para>
        /// Regular expression: (StartAt, Count)
        /// </para>
        /// </summary>
        public virtual Count Count {
            get {                
                XElement x = this.GetElement(CountXName);
                return ((Count)(x));
            }
            set {
                this.SetElement(CountXName, value);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Range", "urn:Microsoft.Search.Query");
    
        static Range() {
            BuildElementDictionary();
            contentModel = new SequenceContentModelEntity(new NamedContentModelEntity(StartAtXName), new NamedContentModelEntity(CountXName));
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static Dictionary<System.Xml.Linq.XName, System.Type> localElementDictionary = new Dictionary<System.Xml.Linq.XName, System.Type>();
        
        private static void BuildElementDictionary() {
            localElementDictionary.Add(StartAtXName, typeof(StartAt));
            localElementDictionary.Add(CountXName, typeof(Count));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        Dictionary<System.Xml.Linq.XName, System.Type> IXMetaData.LocalElementsDictionary {
            get {
                return localElementDictionary;
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static ContentModelEntity contentModel;
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return contentModel;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// Regular expression: (Property+)
    /// </para>
    /// </summary>
    public partial class Properties : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static Properties Load(string xmlFile) {
            return XTypedServices.Load<Properties>(xmlFile);
        }
        
        public static Properties Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<Properties>(xmlFile);
        }
        
        public static Properties Parse(string xml) {
            return XTypedServices.Parse<Properties>(xml);
        }
        
        public static explicit operator Properties(XElement xe) { return XTypedServices.ToXTypedElement<Properties>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<Properties>(this);
        }
    
        /// <summary>
        /// <para>
        /// Regular expression: (Property+)
        /// </para>
        /// </summary>
        public Properties() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName PropertyXName = System.Xml.Linq.XName.Get("Property", "urn:Microsoft.Search.Query");
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private XTypedList<Property> PropertyField;
    
        /// <summary>
        /// <para>
        /// Occurrence: required, repeating
        /// </para>
        /// <para>
        /// Regular expression: (Property+)
        /// </para>
        /// </summary>
        public virtual IList<Property> Property {
            get {
                if ((this.PropertyField == null)) {
                    this.PropertyField = new XTypedList<Property>(this, LinqToXsdTypeManager.Instance, PropertyXName);
                }
                return this.PropertyField;
            }
            set {
                if ((value == null)) {
                    this.PropertyField = null;
                }
                else {
                    if ((this.PropertyField == null)) {
                        this.PropertyField = XTypedList<Property>.Initialize(this, LinqToXsdTypeManager.Instance, value, PropertyXName);
                    }
                    else {
                        XTypedServices.SetList<Property>(this.PropertyField, value);
                    }
                }
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Properties", "urn:Microsoft.Search.Query");
    
        static Properties() {
            BuildElementDictionary();
            contentModel = new SequenceContentModelEntity(new NamedContentModelEntity(PropertyXName));
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static Dictionary<System.Xml.Linq.XName, System.Type> localElementDictionary = new Dictionary<System.Xml.Linq.XName, System.Type>();
        
        private static void BuildElementDictionary() {
            localElementDictionary.Add(PropertyXName, typeof(Property));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        Dictionary<System.Xml.Linq.XName, System.Type> IXMetaData.LocalElementsDictionary {
            get {
                return localElementDictionary;
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static ContentModelEntity contentModel;
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return contentModel;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class Property : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static Property Load(string xmlFile) {
            return XTypedServices.Load<Property>(xmlFile);
        }
        
        public static Property Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<Property>(xmlFile);
        }
        
        public static Property Parse(string xml) {
            return XTypedServices.Parse<Property>(xml);
        }
        
        public static explicit operator Property(XElement xe) { return XTypedServices.ToXTypedElement<Property>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<Property>(this);
        }
    
        public Property() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName nameXName = System.Xml.Linq.XName.Get("name", "");
    
        /// <summary>
        /// <para>
        /// Occurrence: optional
        /// </para>
        /// </summary>
        public virtual string name {
            get {
                XAttribute x = this.Attribute(nameXName);
                if ((x == null)) {
                    return null;
                }
                return XTypedServices.ParseValue<string>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
            set {
                this.SetAttribute(nameXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Property", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// Regular expression: (SortByProperty+)
    /// </para>
    /// </summary>
    public partial class SortByProperties : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static SortByProperties Load(string xmlFile) {
            return XTypedServices.Load<SortByProperties>(xmlFile);
        }
        
        public static SortByProperties Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<SortByProperties>(xmlFile);
        }
        
        public static SortByProperties Parse(string xml) {
            return XTypedServices.Parse<SortByProperties>(xml);
        }
        
        public static explicit operator SortByProperties(XElement xe) { return XTypedServices.ToXTypedElement<SortByProperties>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<SortByProperties>(this);
        }
    
        /// <summary>
        /// <para>
        /// Regular expression: (SortByProperty+)
        /// </para>
        /// </summary>
        public SortByProperties() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName SortByPropertyXName = System.Xml.Linq.XName.Get("SortByProperty", "urn:Microsoft.Search.Query");
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private XTypedList<SortByProperty> SortByPropertyField;
    
        /// <summary>
        /// <para>
        /// Occurrence: required, repeating
        /// </para>
        /// <para>
        /// Regular expression: (SortByProperty+)
        /// </para>
        /// </summary>
        public virtual IList<SortByProperty> SortByProperty {
            get {
                if ((this.SortByPropertyField == null)) {
                    this.SortByPropertyField = new XTypedList<SortByProperty>(this, LinqToXsdTypeManager.Instance, SortByPropertyXName);
                }
                return this.SortByPropertyField;
            }
            set {
                if ((value == null)) {
                    this.SortByPropertyField = null;
                }
                else {
                    if ((this.SortByPropertyField == null)) {
                        this.SortByPropertyField = XTypedList<SortByProperty>.Initialize(this, LinqToXsdTypeManager.Instance, value, SortByPropertyXName);
                    }
                    else {
                        XTypedServices.SetList<SortByProperty>(this.SortByPropertyField, value);
                    }
                }
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("SortByProperties", "urn:Microsoft.Search.Query");
    
        static SortByProperties() {
            BuildElementDictionary();
            contentModel = new SequenceContentModelEntity(new NamedContentModelEntity(SortByPropertyXName));
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static Dictionary<System.Xml.Linq.XName, System.Type> localElementDictionary = new Dictionary<System.Xml.Linq.XName, System.Type>();
        
        private static void BuildElementDictionary() {
            localElementDictionary.Add(SortByPropertyXName, typeof(SortByProperty));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        Dictionary<System.Xml.Linq.XName, System.Type> IXMetaData.LocalElementsDictionary {
            get {
                return localElementDictionary;
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static ContentModelEntity contentModel;
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return contentModel;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class SortByProperty : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static SortByProperty Load(string xmlFile) {
            return XTypedServices.Load<SortByProperty>(xmlFile);
        }
        
        public static SortByProperty Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<SortByProperty>(xmlFile);
        }
        
        public static SortByProperty Parse(string xml) {
            return XTypedServices.Parse<SortByProperty>(xml);
        }
        
        public static explicit operator SortByProperty(XElement xe) { return XTypedServices.ToXTypedElement<SortByProperty>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<SortByProperty>(this);
        }
    
        public SortByProperty() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName nameXName = System.Xml.Linq.XName.Get("name", "");
    
        /// <summary>
        /// <para>
        /// The name of the managed property to sort on.
        ///
        ///The following special conditions apply to FAST Search Server 2010 for SharePoint only:
        ///
        ///* The name attribute may contain the name of a rank profile instead of a managed property. In this case the result set is sorted by Rank, but using the non-default rank profile specified by name. For more information, see Sort Search Results by Rank.
        ///
        ///* The name attribute may contain a sort formula specification. In this case the result set is sorted based on the specified formula. For more information about the syntax, see Sort Search Results by a Formula Expression.
        /// </para>
        /// <para>
        /// Occurrence: optional
        /// </para>
        /// </summary>
        public virtual string name {
            get {
                XAttribute x = this.Attribute(nameXName);
                if ((x == null)) {
                    return null;
                }
                return XTypedServices.ParseValue<string>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
            set {
                this.SetAttribute(nameXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
        }
    
        public enum DirectionEnum {
        
            Ascending,
        
            Descending,
        }
        
        public sealed class DirectionEnumValidator {
        
            private DirectionEnumValidator() {
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), new Xml.Schema.Linq.RestrictionFacets(((Xml.Schema.Linq.RestrictionFlags)(16)), new object[] {
                "Ascending",
                "Descending"}, 0, 0, null, null, 0, null, null, 0, null, 0, XmlSchemaWhiteSpace.Preserve));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName directionXName = System.Xml.Linq.XName.Get("direction", "");
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static Microsoft.Search.Query.Schemas.SortByProperty.DirectionEnum directionDefaultValue = Microsoft.Search.Query.Schemas.SortByProperty.DirectionEnum.Descending;
        
        /// <summary>
        /// <para>
        /// Specifies the direction (ascending or descending) to sort the results.
        ///
        ///* Ascending Sorting is based on ascending value
        ///* Descending Sorting is based on descending value
        ///
        ///Note: This attribute is not used when specifying a rank profile name in the name attribute (rank sorting is always descending). This applies to FAST Search Server 2010 for SharePoint only.
        ///
        ///Defaults to Descending.
        ///
        ///
        /// </para>
        /// <para>
        /// Occurrence: optional
        /// </para>
        /// </summary>
        public virtual Microsoft.Search.Query.Schemas.SortByProperty.DirectionEnum direction {
            get {
                XAttribute x = this.Attribute(directionXName);
                if ((x == null)) {
                    return directionDefaultValue;
                }
                return ((Microsoft.Search.Query.Schemas.SortByProperty.DirectionEnum)(Enum.Parse(typeof(Microsoft.Search.Query.Schemas.SortByProperty.DirectionEnum), XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype, DirectionEnumValidator.TypeDefinition))));
            }
            set {
                this.SetAttributeWithValidation(directionXName, value.ToString(), "direction", DirectionEnumValidator.TypeDefinition);
            }    
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("SortByProperty", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class RelevanceModel : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static RelevanceModel Load(string xmlFile) {
            return XTypedServices.Load<RelevanceModel>(xmlFile);
        }
        
        public static RelevanceModel Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<RelevanceModel>(xmlFile);
        }
        
        public static RelevanceModel Parse(string xml) {
            return XTypedServices.Parse<RelevanceModel>(xml);
        }
        
        public static explicit operator RelevanceModel(XElement xe) { return XTypedServices.ToXTypedElement<RelevanceModel>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<RelevanceModel>(this);
        }
    
        public RelevanceModel() {
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("RelevanceModel", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class TrimDuplicates : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static TrimDuplicates Load(string xmlFile) {
            return XTypedServices.Load<TrimDuplicates>(xmlFile);
        }
        
        public static TrimDuplicates Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<TrimDuplicates>(xmlFile);
        }
        
        public static TrimDuplicates Parse(string xml) {
            return XTypedServices.Parse<TrimDuplicates>(xml);
        }
        
        public static explicit operator TrimDuplicates(XElement xe) { return XTypedServices.ToXTypedElement<TrimDuplicates>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<TrimDuplicates>(this);
        }
    
        public TrimDuplicates() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual bool TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<bool>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName onpropertyXName = System.Xml.Linq.XName.Get("onproperty", "");
    
        /// <summary>
        /// <para>
        /// Optional attribute indicating the name of a non-default managed property to use as the basis for duplicate removal.
        /// </para>
        /// <para>
        /// Occurrence: optional
        /// </para>
        /// </summary>
        public virtual string onproperty {
            get {
                XAttribute x = this.Attribute(onpropertyXName);
                if ((x == null)) {
                    return null;
                }
                return XTypedServices.ParseValue<string>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
            set {
                this.SetAttribute(onpropertyXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName keepcountXName = System.Xml.Linq.XName.Get("keepcount", "");
    
        /// <summary>
        /// <para>
        /// Optional attribute specifying how many items to keep for each set of duplicates.
        ///
        ///The default value is 1.
        /// </para>
        /// <para>
        /// Occurrence: optional
        /// </para>
        /// </summary>
        public virtual System.Int32? keepcount {
            get {
                XAttribute x = this.Attribute(keepcountXName);
                if ((x == null)) {
                    return null;
                }
                return XTypedServices.ParseValue<int>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype);
            }
            set {
                this.SetAttribute(keepcountXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype);
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName includeidXName = System.Xml.Linq.XName.Get("includeid", "");
    
        /// <summary>
        /// <para>
        /// Specifies the value associated with a collapse group, typically used when a user clicks the Duplicates(n) link of an item with duplicates.
        /// </para>
        /// <para>
        /// Occurrence: optional
        /// </para>
        /// </summary>
        public virtual System.Boolean? includeid {
            get {
                XAttribute x = this.Attribute(includeidXName);
                if ((x == null)) {
                    return null;
                }
                return XTypedServices.ParseValue<bool>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
            set {
                this.SetAttribute(includeidXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("TrimDuplicates", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class ResultProvider : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static ResultProvider Load(string xmlFile) {
            return XTypedServices.Load<ResultProvider>(xmlFile);
        }
        
        public static ResultProvider Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<ResultProvider>(xmlFile);
        }
        
        public static ResultProvider Parse(string xml) {
            return XTypedServices.Parse<ResultProvider>(xml);
        }
        
        public static explicit operator ResultProvider(XElement xe) { return XTypedServices.ToXTypedElement<ResultProvider>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<ResultProvider>(this);
        }
    
        public ResultProvider() {
        }
    
        public enum ResultProvider1Enum {
        
            Default,
        
            SharePointSearch,
        
            FASTSearch,
        }
        
        public sealed class ResultProvider1EnumValidator {
        
            private ResultProvider1EnumValidator() {
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), new Xml.Schema.Linq.RestrictionFacets(((Xml.Schema.Linq.RestrictionFlags)(16)), new object[] {
                "Default",
                "SharePointSearch",
                "FASTSearch"}, 0, 0, null, null, 0, null, null, 0, null, 0, XmlSchemaWhiteSpace.Preserve));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual Microsoft.Search.Query.Schemas.ResultProvider.ResultProvider1Enum TypedValue {
            get {
                XElement x = this.Untyped;
                return ((Microsoft.Search.Query.Schemas.ResultProvider.ResultProvider1Enum)(Enum.Parse(typeof(Microsoft.Search.Query.Schemas.ResultProvider.ResultProvider1Enum), XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype, ResultProvider1EnumValidator.TypeDefinition))));
            }
            set {
                this.SetValueWithValidation(value.ToString(), "TypedValue", ResultProvider1EnumValidator.TypeDefinition);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("ResultProvider", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// Regular expression: (ResubmitFlag+)
    /// </para>
    /// </summary>
    public partial class ResubmitFlags : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static ResubmitFlags Load(string xmlFile) {
            return XTypedServices.Load<ResubmitFlags>(xmlFile);
        }
        
        public static ResubmitFlags Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<ResubmitFlags>(xmlFile);
        }
        
        public static ResubmitFlags Parse(string xml) {
            return XTypedServices.Parse<ResubmitFlags>(xml);
        }
        
        public static explicit operator ResubmitFlags(XElement xe) { return XTypedServices.ToXTypedElement<ResubmitFlags>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<ResubmitFlags>(this);
        }
    
        /// <summary>
        /// <para>
        /// Regular expression: (ResubmitFlag+)
        /// </para>
        /// </summary>
        public ResubmitFlags() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName ResubmitFlagXName = System.Xml.Linq.XName.Get("ResubmitFlag", "urn:Microsoft.Search.Query");
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private XTypedList<ResubmitFlag> ResubmitFlagField;
    
        /// <summary>
        /// <para>
        /// The effect of an automatic resubmit is that the query is modified and automatically re-evaluated before results are returned to the client.
        /// </para>
        /// <para>
        /// Occurrence: required, repeating
        /// </para>
        /// <para>
        /// Regular expression: (ResubmitFlag+)
        /// </para>
        /// </summary>
        public virtual IList<ResubmitFlag> ResubmitFlag {
            get {
                if ((this.ResubmitFlagField == null)) {
                    this.ResubmitFlagField = new XTypedList<ResubmitFlag>(this, LinqToXsdTypeManager.Instance, ResubmitFlagXName);
                }
                return this.ResubmitFlagField;
            }
            set {
                if ((value == null)) {
                    this.ResubmitFlagField = null;
                }
                else {
                    if ((this.ResubmitFlagField == null)) {
                        this.ResubmitFlagField = XTypedList<ResubmitFlag>.Initialize(this, LinqToXsdTypeManager.Instance, value, ResubmitFlagXName);
                    }
                    else {
                        XTypedServices.SetList<ResubmitFlag>(this.ResubmitFlagField, value);
                    }
                }
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("ResubmitFlags", "urn:Microsoft.Search.Query");
    
        static ResubmitFlags() {
            BuildElementDictionary();
            contentModel = new SequenceContentModelEntity(new NamedContentModelEntity(ResubmitFlagXName));
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static Dictionary<System.Xml.Linq.XName, System.Type> localElementDictionary = new Dictionary<System.Xml.Linq.XName, System.Type>();
        
        private static void BuildElementDictionary() {
            localElementDictionary.Add(ResubmitFlagXName, typeof(ResubmitFlag));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        Dictionary<System.Xml.Linq.XName, System.Type> IXMetaData.LocalElementsDictionary {
            get {
                return localElementDictionary;
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static ContentModelEntity contentModel;
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return contentModel;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class ResubmitFlag : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static ResubmitFlag Load(string xmlFile) {
            return XTypedServices.Load<ResubmitFlag>(xmlFile);
        }
        
        public static ResubmitFlag Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<ResubmitFlag>(xmlFile);
        }
        
        public static ResubmitFlag Parse(string xml) {
            return XTypedServices.Parse<ResubmitFlag>(xml);
        }
        
        public static explicit operator ResubmitFlag(XElement xe) { return XTypedServices.ToXTypedElement<ResubmitFlag>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<ResubmitFlag>(this);
        }
    
        public ResubmitFlag() {
        }
    
        public enum ValueEnum {
        
            NoResubmit,
        
            EnableSpellcheckOnResubmit,
        
            EnableSpellcheckSuggestOnResubmit,
        
            EnableStemmingOnResubmit,
        
            AddSynonymsAutomatically,
        }
        
        public sealed class ValueEnumValidator {
        
            private ValueEnumValidator() {
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), new Xml.Schema.Linq.RestrictionFacets(((Xml.Schema.Linq.RestrictionFlags)(16)), new object[] {
                "NoResubmit",
                "EnableSpellcheckOnResubmit",
                "EnableSpellcheckSuggestOnResubmit",
                "EnableStemmingOnResubmit",
                "AddSynonymsAutomatically"}, 0, 0, null, null, 0, null, null, 0, null, 0, XmlSchemaWhiteSpace.Preserve));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName valueXName = System.Xml.Linq.XName.Get("value", "");
        
        /// <summary>
        /// <para>
        /// Explanation of values follows.
        ///
        ///NoResubmit: Do not resubmit the query, but return with ZERO results. If this attribute value is set, any other ResubmitFlag elements are ignored.
        ///
        ///EnableSpellcheckOnResubmit: Resubmit the query with automatic spelling checking enabled. This corresponds to evaluating the query with EnableSpellCheck set to 4 when re-evaluating the query.
        ///
        ///EnableSpellcheckSuggestOnResubmit: Resubmit the query with spelling checking enabled in suggest mode. This corresponds to evaluating the query with EnableSpellCheck set to 2 when re-evaluating the query. Note - This option will still return a query result with zero hits.
        ///
        ///EnableStemmingOnResubmit: Resubmit the query with stemming enabled. This corresponds to evaluating the query with EnableStemming set to true when re-evaluating the query.
        /// </para>
        /// <para>
        /// Occurrence: optional
        /// </para>
        /// </summary>
        public virtual Microsoft.Search.Query.Schemas.ResubmitFlag.ValueEnum? value {
            get {
                XAttribute x = this.Attribute(valueXName);
                if ((x == null)) {
                    return null;
                }
                return ((Microsoft.Search.Query.Schemas.ResubmitFlag.ValueEnum)(Enum.Parse(typeof(Microsoft.Search.Query.Schemas.ResubmitFlag.ValueEnum), XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype, ValueEnumValidator.TypeDefinition))));
            }
            set {
                if (value == null) {
                    this.SetAttribute(valueXName, null, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
                }
                else {
                    this.SetAttributeWithValidation(valueXName, value.ToString(), "value", ValueEnumValidator.TypeDefinition);    
                }
            }    
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("ResubmitFlag", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// Off: Do not apply spelling correction to the query text.
    ///Suggest: Suggest transformed (spelled correctly) query in the result, but do not apply spelling checking to the actual query performed. This enables the Did You Mean feature search tip in the result pages.
    ///On: Apply spelling corrections to the query text before evaluating the query.
    /// </para>
    /// </summary>
    public partial class EnableSpellcheck : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static EnableSpellcheck Load(string xmlFile) {
            return XTypedServices.Load<EnableSpellcheck>(xmlFile);
        }
        
        public static EnableSpellcheck Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<EnableSpellcheck>(xmlFile);
        }
        
        public static EnableSpellcheck Parse(string xml) {
            return XTypedServices.Parse<EnableSpellcheck>(xml);
        }
        
        public static explicit operator EnableSpellcheck(XElement xe) { return XTypedServices.ToXTypedElement<EnableSpellcheck>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<EnableSpellcheck>(this);
        }
    
        /// <summary>
        /// <para>
        /// Off: Do not apply spelling correction to the query text.
        ///Suggest: Suggest transformed (spelled correctly) query in the result, but do not apply spelling checking to the actual query performed. This enables the Did You Mean feature search tip in the result pages.
        ///On: Apply spelling corrections to the query text before evaluating the query.
        /// </para>
        /// </summary>
        public EnableSpellcheck() {
        }
    
        public enum EnableSpellcheck1Enum {
        
            off,
        
            suggest,
        
            on,
        }
        
        public sealed class EnableSpellcheck1EnumValidator {
        
            private EnableSpellcheck1EnumValidator() {
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), new Xml.Schema.Linq.RestrictionFacets(((Xml.Schema.Linq.RestrictionFlags)(16)), new object[] {
                "off",
                "suggest",
                "on"}, 0, 0, null, null, 0, null, null, 0, null, 0, XmlSchemaWhiteSpace.Preserve));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual Microsoft.Search.Query.Schemas.EnableSpellcheck.EnableSpellcheck1Enum TypedValue {
            get {
                XElement x = this.Untyped;
                return ((Microsoft.Search.Query.Schemas.EnableSpellcheck.EnableSpellcheck1Enum)(Enum.Parse(typeof(Microsoft.Search.Query.Schemas.EnableSpellcheck.EnableSpellcheck1Enum), XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype, EnableSpellcheck1EnumValidator.TypeDefinition))));
            }
            set {
                this.SetValueWithValidation(value.ToString(), "TypedValue", EnableSpellcheck1EnumValidator.TypeDefinition);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("EnableSpellcheck", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// Regular expression: (UserContextData)
    /// </para>
    /// </summary>
    public partial class UserContext : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static UserContext Load(string xmlFile) {
            return XTypedServices.Load<UserContext>(xmlFile);
        }
        
        public static UserContext Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<UserContext>(xmlFile);
        }
        
        public static UserContext Parse(string xml) {
            return XTypedServices.Parse<UserContext>(xml);
        }
        
        public static explicit operator UserContext(XElement xe) { return XTypedServices.ToXTypedElement<UserContext>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<UserContext>(this);
        }
    
        /// <summary>
        /// <para>
        /// Regular expression: (UserContextData)
        /// </para>
        /// </summary>
        public UserContext() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName UserContextDataXName = System.Xml.Linq.XName.Get("UserContextData", "urn:Microsoft.Search.Query");
    
        /// <summary>
        /// <para>
        /// The keyword management search settings can be restricted to context. A context defines when a search setting should apply, typically targeting a specific group of users.
        ///
        ///If a user with the responsibilities "developer" and "tester" submits a query for "office", the query request should include the following userContextString: "responsibilities:;:developer;tester"
        ///
        /// </para>
        /// <para>
        /// Occurrence: required
        /// </para>
        /// <para>
        /// Regular expression: (UserContextData)
        /// </para>
        /// </summary>
        public virtual UserContextData UserContextData {
            get {                
                XElement x = this.GetElement(UserContextDataXName);
                return ((UserContextData)(x));
            }
            set {
                this.SetElement(UserContextDataXName, value);
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName includeuserprofileXName = System.Xml.Linq.XName.Get("includeuserprofile", "");
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static bool includeuserprofileDefaultValue = System.Xml.XmlConvert.ToBoolean("true");
    
        /// <summary>
        /// <para>
        /// Specifies the type of user context data to be applied.
        ///
        ///true  Context values from the SharePoint 2010 user profile service will be included as part of the user context. If UserContextData is also used, the user profile data and the custom context data are both used.
        ///
        ///false  Context values from the SharePoint 2010 user profile are not included as part of the user context. Use UserContextData to submit custom user contexts.
        ///
        ///Default: true.
        /// </para>
        /// <para>
        /// Occurrence: optional
        /// </para>
        /// </summary>
        public virtual bool includeuserprofile {
            get {
                XAttribute x = this.Attribute(includeuserprofileXName);
                if ((x == null)) {
                    return includeuserprofileDefaultValue;
                }
                return XTypedServices.ParseValue<bool>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
            set {
                this.SetAttribute(includeuserprofileXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("UserContext", "urn:Microsoft.Search.Query");
    
        static UserContext() {
            BuildElementDictionary();
            contentModel = new SequenceContentModelEntity(new NamedContentModelEntity(UserContextDataXName));
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static Dictionary<System.Xml.Linq.XName, System.Type> localElementDictionary = new Dictionary<System.Xml.Linq.XName, System.Type>();
        
        private static void BuildElementDictionary() {
            localElementDictionary.Add(UserContextDataXName, typeof(UserContextData));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        Dictionary<System.Xml.Linq.XName, System.Type> IXMetaData.LocalElementsDictionary {
            get {
                return localElementDictionary;
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static ContentModelEntity contentModel;
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return contentModel;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// Regular expression: (SimilarTo, SimilarType, SortSimilar)
    /// </para>
    /// </summary>
    public partial class FindSimilar : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static FindSimilar Load(string xmlFile) {
            return XTypedServices.Load<FindSimilar>(xmlFile);
        }
        
        public static FindSimilar Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<FindSimilar>(xmlFile);
        }
        
        public static FindSimilar Parse(string xml) {
            return XTypedServices.Parse<FindSimilar>(xml);
        }
        
        public static explicit operator FindSimilar(XElement xe) { return XTypedServices.ToXTypedElement<FindSimilar>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<FindSimilar>(this);
        }
    
        /// <summary>
        /// <para>
        /// Regular expression: (SimilarTo, SimilarType, SortSimilar)
        /// </para>
        /// </summary>
        public FindSimilar() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName SimilarToXName = System.Xml.Linq.XName.Get("SimilarTo", "urn:Microsoft.Search.Query");
    
        /// <summary>
        /// <para>
        /// Occurrence: required
        /// </para>
        /// <para>
        /// Regular expression: (SimilarTo, SimilarType, SortSimilar)
        /// </para>
        /// </summary>
        public virtual SimilarTo SimilarTo {
            get {                
                XElement x = this.GetElement(SimilarToXName);
                return ((SimilarTo)(x));
            }
            set {
                this.SetElement(SimilarToXName, value);
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName SimilarTypeXName = System.Xml.Linq.XName.Get("SimilarType", "urn:Microsoft.Search.Query");
    
        /// <summary>
        /// <para>
        /// An explanation of possible values follows.
        ///
        ///FindSimilar: The similarity vectors are added to the query by using an OR operator.
        ///RefineSimilar: The query will match if the original query conditions and the similarity vector conditions are met.
        ///ExcludeSimilar: The query will match if the original query conditions are met, but not the similarity conditions.
        /// </para>
        /// <para>
        /// Occurrence: required
        /// </para>
        /// <para>
        /// Regular expression: (SimilarTo, SimilarType, SortSimilar)
        /// </para>
        /// </summary>
        public virtual Microsoft.Search.Query.Schemas.SimilarType SimilarType {
            get {                
                XElement x = this.GetElement(SimilarTypeXName);
                return ((Microsoft.Search.Query.Schemas.SimilarType)(x));
            }
            set {
                this.SetElement(SimilarTypeXName, value);
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName SortSimilarXName = System.Xml.Linq.XName.Get("SortSimilar", "urn:Microsoft.Search.Query");
    
        /// <summary>
        /// <para>
        /// If set to False, the result is sorted by relevance score (rank). Default: true.
        /// </para>
        /// <para>
        /// Occurrence: required
        /// </para>
        /// <para>
        /// Regular expression: (SimilarTo, SimilarType, SortSimilar)
        /// </para>
        /// </summary>
        public virtual SortSimilar SortSimilar {
            get {                
                XElement x = this.GetElement(SortSimilarXName);
                return ((SortSimilar)(x));
            }
            set {
                this.SetElement(SortSimilarXName, value);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("FindSimilar", "urn:Microsoft.Search.Query");
    
        static FindSimilar() {
            BuildElementDictionary();
            contentModel = new SequenceContentModelEntity(new NamedContentModelEntity(SimilarToXName), new NamedContentModelEntity(SimilarTypeXName), new NamedContentModelEntity(SortSimilarXName));
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static Dictionary<System.Xml.Linq.XName, System.Type> localElementDictionary = new Dictionary<System.Xml.Linq.XName, System.Type>();
        
        private static void BuildElementDictionary() {
            localElementDictionary.Add(SimilarToXName, typeof(SimilarTo));
            localElementDictionary.Add(SimilarTypeXName, typeof(SimilarType));
            localElementDictionary.Add(SortSimilarXName, typeof(SortSimilar));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        Dictionary<System.Xml.Linq.XName, System.Type> IXMetaData.LocalElementsDictionary {
            get {
                return localElementDictionary;
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static ContentModelEntity contentModel;
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return contentModel;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class SimilarType : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static SimilarType Load(string xmlFile) {
            return XTypedServices.Load<SimilarType>(xmlFile);
        }
        
        public static SimilarType Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<SimilarType>(xmlFile);
        }
        
        public static SimilarType Parse(string xml) {
            return XTypedServices.Parse<SimilarType>(xml);
        }
        
        public static explicit operator SimilarType(XElement xe) { return XTypedServices.ToXTypedElement<SimilarType>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<SimilarType>(this);
        }
    
        public SimilarType() {
        }
    
        public enum SimilarType1Enum {
        
            FindSimilar,
        
            RefineSimilar,
        
            ExcludeSimilar,
        }
        
        public sealed class SimilarType1EnumValidator {
        
            private SimilarType1EnumValidator() {
            }
        
            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
            public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), new Xml.Schema.Linq.RestrictionFacets(((Xml.Schema.Linq.RestrictionFlags)(16)), new object[] {
                "FindSimilar",
                "RefineSimilar",
                "ExcludeSimilar"}, 0, 0, null, null, 0, null, null, 0, null, 0, XmlSchemaWhiteSpace.Preserve));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual Microsoft.Search.Query.Schemas.SimilarType.SimilarType1Enum TypedValue {
            get {
                XElement x = this.Untyped;
                return ((Microsoft.Search.Query.Schemas.SimilarType.SimilarType1Enum)(Enum.Parse(typeof(Microsoft.Search.Query.Schemas.SimilarType.SimilarType1Enum), XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype, SimilarType1EnumValidator.TypeDefinition))));
            }
            set {
                this.SetValueWithValidation(value.ToString(), "TypedValue", SimilarType1EnumValidator.TypeDefinition);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("SimilarType", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// Regular expression: (Refiners, MaxShallowRefinementHits)
    /// </para>
    /// </summary>
    public partial class IncludeRefinementResults : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static IncludeRefinementResults Load(string xmlFile) {
            return XTypedServices.Load<IncludeRefinementResults>(xmlFile);
        }
        
        public static IncludeRefinementResults Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<IncludeRefinementResults>(xmlFile);
        }
        
        public static IncludeRefinementResults Parse(string xml) {
            return XTypedServices.Parse<IncludeRefinementResults>(xml);
        }
        
        public static explicit operator IncludeRefinementResults(XElement xe) { return XTypedServices.ToXTypedElement<IncludeRefinementResults>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<IncludeRefinementResults>(this);
        }
    
        /// <summary>
        /// <para>
        /// Regular expression: (Refiners, MaxShallowRefinementHits)
        /// </para>
        /// </summary>
        public IncludeRefinementResults() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName RefinersXName = System.Xml.Linq.XName.Get("Refiners", "urn:Microsoft.Search.Query");
    
        /// <summary>
        /// <para>
        /// Occurrence: required
        /// </para>
        /// <para>
        /// Regular expression: (Refiners, MaxShallowRefinementHits)
        /// </para>
        /// </summary>
        public virtual Refiners Refiners {
            get {                
                XElement x = this.GetElement(RefinersXName);
                return ((Refiners)(x));
            }
            set {
                this.SetElement(RefinersXName, value);
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName MaxShallowRefinementHitsXName = System.Xml.Linq.XName.Get("MaxShallowRefinementHits", "urn:Microsoft.Search.Query");
    
        /// <summary>
        /// <para>
        /// Occurrence: required
        /// </para>
        /// <para>
        /// Regular expression: (Refiners, MaxShallowRefinementHits)
        /// </para>
        /// </summary>
        public virtual MaxShallowRefinementHits MaxShallowRefinementHits {
            get {                
                XElement x = this.GetElement(MaxShallowRefinementHitsXName);
                return ((MaxShallowRefinementHits)(x));
            }
            set {
                this.SetElement(MaxShallowRefinementHitsXName, value);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("IncludeRefinementResults", "urn:Microsoft.Search.Query");
    
        static IncludeRefinementResults() {
            BuildElementDictionary();
            contentModel = new SequenceContentModelEntity(new NamedContentModelEntity(RefinersXName), new NamedContentModelEntity(MaxShallowRefinementHitsXName));
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static Dictionary<System.Xml.Linq.XName, System.Type> localElementDictionary = new Dictionary<System.Xml.Linq.XName, System.Type>();
        
        private static void BuildElementDictionary() {
            localElementDictionary.Add(RefinersXName, typeof(Refiners));
            localElementDictionary.Add(MaxShallowRefinementHitsXName, typeof(MaxShallowRefinementHits));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        Dictionary<System.Xml.Linq.XName, System.Type> IXMetaData.LocalElementsDictionary {
            get {
                return localElementDictionary;
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static ContentModelEntity contentModel;
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return contentModel;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// Regular expression: (Refiner)
    /// </para>
    /// </summary>
    public partial class Refiners : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static Refiners Load(string xmlFile) {
            return XTypedServices.Load<Refiners>(xmlFile);
        }
        
        public static Refiners Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<Refiners>(xmlFile);
        }
        
        public static Refiners Parse(string xml) {
            return XTypedServices.Parse<Refiners>(xml);
        }
        
        public static explicit operator Refiners(XElement xe) { return XTypedServices.ToXTypedElement<Refiners>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<Refiners>(this);
        }
    
        /// <summary>
        /// <para>
        /// Regular expression: (Refiner)
        /// </para>
        /// </summary>
        public Refiners() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName RefinerXName = System.Xml.Linq.XName.Get("Refiner", "urn:Microsoft.Search.Query");
    
        /// <summary>
        /// <para>
        /// Occurrence: required
        /// </para>
        /// <para>
        /// Regular expression: (Refiner)
        /// </para>
        /// </summary>
        public virtual Refiner Refiner {
            get {                
                XElement x = this.GetElement(RefinerXName);
                return ((Refiner)(x));
            }
            set {
                this.SetElement(RefinerXName, value);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Refiners", "urn:Microsoft.Search.Query");
    
        static Refiners() {
            BuildElementDictionary();
            contentModel = new SequenceContentModelEntity(new NamedContentModelEntity(RefinerXName));
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static Dictionary<System.Xml.Linq.XName, System.Type> localElementDictionary = new Dictionary<System.Xml.Linq.XName, System.Type>();
        
        private static void BuildElementDictionary() {
            localElementDictionary.Add(RefinerXName, typeof(Refiner));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        Dictionary<System.Xml.Linq.XName, System.Type> IXMetaData.LocalElementsDictionary {
            get {
                return localElementDictionary;
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static ContentModelEntity contentModel;
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return contentModel;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// Regular expression: (RefinementFilter)
    /// </para>
    /// </summary>
    public partial class RefinementFilters : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static RefinementFilters Load(string xmlFile) {
            return XTypedServices.Load<RefinementFilters>(xmlFile);
        }
        
        public static RefinementFilters Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<RefinementFilters>(xmlFile);
        }
        
        public static RefinementFilters Parse(string xml) {
            return XTypedServices.Parse<RefinementFilters>(xml);
        }
        
        public static explicit operator RefinementFilters(XElement xe) { return XTypedServices.ToXTypedElement<RefinementFilters>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<RefinementFilters>(this);
        }
    
        /// <summary>
        /// <para>
        /// Regular expression: (RefinementFilter)
        /// </para>
        /// </summary>
        public RefinementFilters() {
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName RefinementFilterXName = System.Xml.Linq.XName.Get("RefinementFilter", "urn:Microsoft.Search.Query");
    
        /// <summary>
        /// <para>
        /// Occurrence: required
        /// </para>
        /// <para>
        /// Regular expression: (RefinementFilter)
        /// </para>
        /// </summary>
        public virtual RefinementFilter RefinementFilter {
            get {                
                XElement x = this.GetElement(RefinementFilterXName);
                return ((RefinementFilter)(x));
            }
            set {
                this.SetElement(RefinementFilterXName, value);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("RefinementFilters", "urn:Microsoft.Search.Query");
    
        static RefinementFilters() {
            BuildElementDictionary();
            contentModel = new SequenceContentModelEntity(new NamedContentModelEntity(RefinementFilterXName));
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static Dictionary<System.Xml.Linq.XName, System.Type> localElementDictionary = new Dictionary<System.Xml.Linq.XName, System.Type>();
        
        private static void BuildElementDictionary() {
            localElementDictionary.Add(RefinementFilterXName, typeof(RefinementFilter));
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        Dictionary<System.Xml.Linq.XName, System.Type> IXMetaData.LocalElementsDictionary {
            get {
                return localElementDictionary;
            }
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static ContentModelEntity contentModel;
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return contentModel;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// The similarityReference is a string that represents a statistical similarity reference when searching for similar items.
    /// </para>
    /// </summary>
    public sealed class similarityReference {
        
        private similarityReference() {
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
    }
    
    /// <summary>
    /// <para>
    /// This contains the name of the refiner, but you can also use an advanced syntax to apply non-default configuration values for the named refiner. For more information about the advanced syntax for the Refiner element, see Refiner Specification in the Query Web Service and Query Object Model (https://docs.microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/gg984547%28v%3doffice.14%29).
    /// </para>
    /// </summary>
    public sealed class refinerSpecification {
        
        private refinerSpecification() {
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
    }
    
    public partial class StartAt : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static StartAt Load(string xmlFile) {
            return XTypedServices.Load<StartAt>(xmlFile);
        }
        
        public static StartAt Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<StartAt>(xmlFile);
        }
        
        public static StartAt Parse(string xml) {
            return XTypedServices.Parse<StartAt>(xml);
        }
        
        public static explicit operator StartAt(XElement xe) { return XTypedServices.ToXTypedElement<StartAt>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<StartAt>(this);
        }
    
        public StartAt() {
        }
    
        public StartAt(int content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual int TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<int>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("StartAt", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class Count : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static Count Load(string xmlFile) {
            return XTypedServices.Load<Count>(xmlFile);
        }
        
        public static Count Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<Count>(xmlFile);
        }
        
        public static Count Parse(string xml) {
            return XTypedServices.Parse<Count>(xml);
        }
        
        public static explicit operator Count(XElement xe) { return XTypedServices.ToXTypedElement<Count>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<Count>(this);
        }
    
        public Count() {
        }
    
        public Count(int content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual int TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<int>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Count", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class ImplicitAndBehavior : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static ImplicitAndBehavior Load(string xmlFile) {
            return XTypedServices.Load<ImplicitAndBehavior>(xmlFile);
        }
        
        public static ImplicitAndBehavior Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<ImplicitAndBehavior>(xmlFile);
        }
        
        public static ImplicitAndBehavior Parse(string xml) {
            return XTypedServices.Parse<ImplicitAndBehavior>(xml);
        }
        
        public static explicit operator ImplicitAndBehavior(XElement xe) { return XTypedServices.ToXTypedElement<ImplicitAndBehavior>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<ImplicitAndBehavior>(this);
        }
    
        public ImplicitAndBehavior() {
        }
    
        public ImplicitAndBehavior(bool content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual bool TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<bool>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("ImplicitAndBehavior", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class EnableStemming : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static EnableStemming Load(string xmlFile) {
            return XTypedServices.Load<EnableStemming>(xmlFile);
        }
        
        public static EnableStemming Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<EnableStemming>(xmlFile);
        }
        
        public static EnableStemming Parse(string xml) {
            return XTypedServices.Parse<EnableStemming>(xml);
        }
        
        public static explicit operator EnableStemming(XElement xe) { return XTypedServices.ToXTypedElement<EnableStemming>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<EnableStemming>(this);
        }
    
        public EnableStemming() {
        }
    
        public EnableStemming(bool content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual bool TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<bool>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("EnableStemming", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class IncludeSpecialTermResults : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static IncludeSpecialTermResults Load(string xmlFile) {
            return XTypedServices.Load<IncludeSpecialTermResults>(xmlFile);
        }
        
        public static IncludeSpecialTermResults Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<IncludeSpecialTermResults>(xmlFile);
        }
        
        public static IncludeSpecialTermResults Parse(string xml) {
            return XTypedServices.Parse<IncludeSpecialTermResults>(xml);
        }
        
        public static explicit operator IncludeSpecialTermResults(XElement xe) { return XTypedServices.ToXTypedElement<IncludeSpecialTermResults>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<IncludeSpecialTermResults>(this);
        }
    
        public IncludeSpecialTermResults() {
        }
    
        public IncludeSpecialTermResults(bool content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual bool TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<bool>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("IncludeSpecialTermResults", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class PreQuerySuggestions : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static PreQuerySuggestions Load(string xmlFile) {
            return XTypedServices.Load<PreQuerySuggestions>(xmlFile);
        }
        
        public static PreQuerySuggestions Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<PreQuerySuggestions>(xmlFile);
        }
        
        public static PreQuerySuggestions Parse(string xml) {
            return XTypedServices.Parse<PreQuerySuggestions>(xml);
        }
        
        public static explicit operator PreQuerySuggestions(XElement xe) { return XTypedServices.ToXTypedElement<PreQuerySuggestions>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<PreQuerySuggestions>(this);
        }
    
        public PreQuerySuggestions() {
        }
    
        public PreQuerySuggestions(bool content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual bool TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<bool>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("PreQuerySuggestions", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class HighlightQuerySuggestions : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static HighlightQuerySuggestions Load(string xmlFile) {
            return XTypedServices.Load<HighlightQuerySuggestions>(xmlFile);
        }
        
        public static HighlightQuerySuggestions Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<HighlightQuerySuggestions>(xmlFile);
        }
        
        public static HighlightQuerySuggestions Parse(string xml) {
            return XTypedServices.Parse<HighlightQuerySuggestions>(xml);
        }
        
        public static explicit operator HighlightQuerySuggestions(XElement xe) { return XTypedServices.ToXTypedElement<HighlightQuerySuggestions>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<HighlightQuerySuggestions>(this);
        }
    
        public HighlightQuerySuggestions() {
        }
    
        public HighlightQuerySuggestions(bool content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual bool TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<bool>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("HighlightQuerySuggestions", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class CapitalizeFirstLetters : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static CapitalizeFirstLetters Load(string xmlFile) {
            return XTypedServices.Load<CapitalizeFirstLetters>(xmlFile);
        }
        
        public static CapitalizeFirstLetters Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<CapitalizeFirstLetters>(xmlFile);
        }
        
        public static CapitalizeFirstLetters Parse(string xml) {
            return XTypedServices.Parse<CapitalizeFirstLetters>(xml);
        }
        
        public static explicit operator CapitalizeFirstLetters(XElement xe) { return XTypedServices.ToXTypedElement<CapitalizeFirstLetters>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<CapitalizeFirstLetters>(this);
        }
    
        public CapitalizeFirstLetters() {
        }
    
        public CapitalizeFirstLetters(bool content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual bool TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<bool>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("CapitalizeFirstLetters", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class UserContextData : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static UserContextData Load(string xmlFile) {
            return XTypedServices.Load<UserContextData>(xmlFile);
        }
        
        public static UserContextData Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<UserContextData>(xmlFile);
        }
        
        public static UserContextData Parse(string xml) {
            return XTypedServices.Parse<UserContextData>(xml);
        }
        
        public static explicit operator UserContextData(XElement xe) { return XTypedServices.ToXTypedElement<UserContextData>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<UserContextData>(this);
        }
    
        public UserContextData() {
        }
    
        public UserContextData(string content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual string TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<string>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("UserContextData", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// The similarityReference is a string that represents a statistical similarity reference when searching for similar items.
    /// </para>
    /// </summary>
    public partial class SimilarTo : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static SimilarTo Load(string xmlFile) {
            return XTypedServices.Load<SimilarTo>(xmlFile);
        }
        
        public static SimilarTo Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<SimilarTo>(xmlFile);
        }
        
        public static SimilarTo Parse(string xml) {
            return XTypedServices.Parse<SimilarTo>(xml);
        }
        
        public static explicit operator SimilarTo(XElement xe) { return XTypedServices.ToXTypedElement<SimilarTo>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<SimilarTo>(this);
        }
    
        /// <summary>
        /// <para>
        /// The similarityReference is a string that represents a statistical similarity reference when searching for similar items.
        /// </para>
        /// </summary>
        public SimilarTo() {
        }
    
        /// <summary>
        /// <para>
        /// The similarityReference is a string that represents a statistical similarity reference when searching for similar items.
        /// </para>
        /// </summary>
        public SimilarTo(string content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual string TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<string>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
            set {
                this.SetValueWithValidation(value, "TypedValue", global::Microsoft.Search.Query.Schemas.similarityReference.TypeDefinition);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("SimilarTo", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class SortSimilar : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static SortSimilar Load(string xmlFile) {
            return XTypedServices.Load<SortSimilar>(xmlFile);
        }
        
        public static SortSimilar Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<SortSimilar>(xmlFile);
        }
        
        public static SortSimilar Parse(string xml) {
            return XTypedServices.Parse<SortSimilar>(xml);
        }
        
        public static explicit operator SortSimilar(XElement xe) { return XTypedServices.ToXTypedElement<SortSimilar>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<SortSimilar>(this);
        }
    
        public SortSimilar() {
        }
    
        public SortSimilar(bool content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual bool TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<bool>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("SortSimilar", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    /// <summary>
    /// <para>
    /// This contains the name of the refiner, but you can also use an advanced syntax to apply non-default configuration values for the named refiner. For more information about the advanced syntax for the Refiner element, see Refiner Specification in the Query Web Service and Query Object Model (https://docs.microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/gg984547%28v%3doffice.14%29).
    /// </para>
    /// </summary>
    public partial class Refiner : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static Refiner Load(string xmlFile) {
            return XTypedServices.Load<Refiner>(xmlFile);
        }
        
        public static Refiner Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<Refiner>(xmlFile);
        }
        
        public static Refiner Parse(string xml) {
            return XTypedServices.Parse<Refiner>(xml);
        }
        
        public static explicit operator Refiner(XElement xe) { return XTypedServices.ToXTypedElement<Refiner>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<Refiner>(this);
        }
    
        /// <summary>
        /// <para>
        /// This contains the name of the refiner, but you can also use an advanced syntax to apply non-default configuration values for the named refiner. For more information about the advanced syntax for the Refiner element, see Refiner Specification in the Query Web Service and Query Object Model (https://docs.microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/gg984547%28v%3doffice.14%29).
        /// </para>
        /// </summary>
        public Refiner() {
        }
    
        /// <summary>
        /// <para>
        /// This contains the name of the refiner, but you can also use an advanced syntax to apply non-default configuration values for the named refiner. For more information about the advanced syntax for the Refiner element, see Refiner Specification in the Query Web Service and Query Object Model (https://docs.microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/gg984547%28v%3doffice.14%29).
        /// </para>
        /// </summary>
        public Refiner(string content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual string TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<string>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
            }
            set {
                this.SetValueWithValidation(value, "TypedValue", global::Microsoft.Search.Query.Schemas.refinerSpecification.TypeDefinition);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Refiner", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class MaxShallowRefinementHits : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static MaxShallowRefinementHits Load(string xmlFile) {
            return XTypedServices.Load<MaxShallowRefinementHits>(xmlFile);
        }
        
        public static MaxShallowRefinementHits Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<MaxShallowRefinementHits>(xmlFile);
        }
        
        public static MaxShallowRefinementHits Parse(string xml) {
            return XTypedServices.Parse<MaxShallowRefinementHits>(xml);
        }
        
        public static explicit operator MaxShallowRefinementHits(XElement xe) { return XTypedServices.ToXTypedElement<MaxShallowRefinementHits>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<MaxShallowRefinementHits>(this);
        }
    
        public MaxShallowRefinementHits() {
        }
    
        public MaxShallowRefinementHits(int content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual int TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<int>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("MaxShallowRefinementHits", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class RefinementFilter : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static RefinementFilter Load(string xmlFile) {
            return XTypedServices.Load<RefinementFilter>(xmlFile);
        }
        
        public static RefinementFilter Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<RefinementFilter>(xmlFile);
        }
        
        public static RefinementFilter Parse(string xml) {
            return XTypedServices.Parse<RefinementFilter>(xml);
        }
        
        public static explicit operator RefinementFilter(XElement xe) { return XTypedServices.ToXTypedElement<RefinementFilter>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<RefinementFilter>(this);
        }
    
        public RefinementFilter() {
        }
    
        public RefinementFilter(byte[] content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual byte[] TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<byte[]>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Base64Binary).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Base64Binary).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("RefinementFilter", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class IgnoreAllNoiseQuery : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static IgnoreAllNoiseQuery Load(string xmlFile) {
            return XTypedServices.Load<IgnoreAllNoiseQuery>(xmlFile);
        }
        
        public static IgnoreAllNoiseQuery Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<IgnoreAllNoiseQuery>(xmlFile);
        }
        
        public static IgnoreAllNoiseQuery Parse(string xml) {
            return XTypedServices.Parse<IgnoreAllNoiseQuery>(xml);
        }
        
        public static explicit operator IgnoreAllNoiseQuery(XElement xe) { return XTypedServices.ToXTypedElement<IgnoreAllNoiseQuery>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<IgnoreAllNoiseQuery>(this);
        }
    
        public IgnoreAllNoiseQuery() {
        }
    
        public IgnoreAllNoiseQuery(bool content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual bool TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<bool>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("IgnoreAllNoiseQuery", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class IncludeRelevantResults : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static IncludeRelevantResults Load(string xmlFile) {
            return XTypedServices.Load<IncludeRelevantResults>(xmlFile);
        }
        
        public static IncludeRelevantResults Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<IncludeRelevantResults>(xmlFile);
        }
        
        public static IncludeRelevantResults Parse(string xml) {
            return XTypedServices.Parse<IncludeRelevantResults>(xml);
        }
        
        public static explicit operator IncludeRelevantResults(XElement xe) { return XTypedServices.ToXTypedElement<IncludeRelevantResults>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<IncludeRelevantResults>(this);
        }
    
        public IncludeRelevantResults() {
        }
    
        public IncludeRelevantResults(bool content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual bool TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<bool>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("IncludeRelevantResults", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }
    
    public partial class IncludeHighConfidenceResults : XTypedElement, IXMetaData {
    
        public void Save(string xmlFile) {
            XTypedServices.Save(xmlFile, Untyped);
        }
        
        public void Save(System.IO.TextWriter tw) {
            XTypedServices.Save(tw, Untyped);
        }
        
        public void Save(System.Xml.XmlWriter xmlWriter) {
            XTypedServices.Save(xmlWriter, Untyped);
        }
        
        public static IncludeHighConfidenceResults Load(string xmlFile) {
            return XTypedServices.Load<IncludeHighConfidenceResults>(xmlFile);
        }
        
        public static IncludeHighConfidenceResults Load(System.IO.TextReader xmlFile) {
            return XTypedServices.Load<IncludeHighConfidenceResults>(xmlFile);
        }
        
        public static IncludeHighConfidenceResults Parse(string xml) {
            return XTypedServices.Parse<IncludeHighConfidenceResults>(xml);
        }
        
        public static explicit operator IncludeHighConfidenceResults(XElement xe) { return XTypedServices.ToXTypedElement<IncludeHighConfidenceResults>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
        
        public override XTypedElement Clone() {
            return XTypedServices.CloneXTypedElement<IncludeHighConfidenceResults>(this);
        }
    
        public IncludeHighConfidenceResults() {
        }
    
        public IncludeHighConfidenceResults(bool content) {
            this.TypedValue = content;
        }
    
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        protected internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
        
        public virtual bool TypedValue {
            get {
                XElement x = this.Untyped;
                return XTypedServices.ParseValue<bool>(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
            set {
                this.SetValue(value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype);
            }
        }
    
        private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("IncludeHighConfidenceResults", "urn:Microsoft.Search.Query");
        
        ContentModelEntity IXMetaData.GetContentModel() {
            return ContentModelEntity.Default;
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        System.Xml.Linq.XName IXMetaData.SchemaName {
            get {
                return xName;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        SchemaOrigin IXMetaData.TypeOrigin {
            get {
                return SchemaOrigin.Element;
            }
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        ILinqToXsdTypeManager IXMetaData.TypeManager {
            get {
                return LinqToXsdTypeManager.Instance;
            }
        }
    }

    public class LinqToXsdTypeManager : ILinqToXsdTypeManager {
        
        private LinqToXsdTypeManager() {
        }
        
        private static Dictionary<System.Xml.Linq.XName, System.Type> elementDictionary = new Dictionary<System.Xml.Linq.XName, System.Type>();
        
        private static void BuildElementDictionary() {
            elementDictionary.Add(System.Xml.Linq.XName.Get("QueryPacket", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.QueryPacket));
            elementDictionary.Add(System.Xml.Linq.XName.Get("QueryId", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.QueryId));
            elementDictionary.Add(System.Xml.Linq.XName.Get("Context", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.Context));
            elementDictionary.Add(System.Xml.Linq.XName.Get("QueryText", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.QueryText));
            elementDictionary.Add(System.Xml.Linq.XName.Get("Range", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.Range));
            elementDictionary.Add(System.Xml.Linq.XName.Get("Properties", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.Properties));
            elementDictionary.Add(System.Xml.Linq.XName.Get("Property", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.Property));
            elementDictionary.Add(System.Xml.Linq.XName.Get("SortByProperties", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.SortByProperties));
            elementDictionary.Add(System.Xml.Linq.XName.Get("SortByProperty", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.SortByProperty));
            elementDictionary.Add(System.Xml.Linq.XName.Get("RelevanceModel", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.RelevanceModel));
            elementDictionary.Add(System.Xml.Linq.XName.Get("TrimDuplicates", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.TrimDuplicates));
            elementDictionary.Add(System.Xml.Linq.XName.Get("ResultProvider", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.ResultProvider));
            elementDictionary.Add(System.Xml.Linq.XName.Get("ResubmitFlags", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.ResubmitFlags));
            elementDictionary.Add(System.Xml.Linq.XName.Get("ResubmitFlag", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.ResubmitFlag));
            elementDictionary.Add(System.Xml.Linq.XName.Get("EnableSpellcheck", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.EnableSpellcheck));
            elementDictionary.Add(System.Xml.Linq.XName.Get("UserContext", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.UserContext));
            elementDictionary.Add(System.Xml.Linq.XName.Get("FindSimilar", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.FindSimilar));
            elementDictionary.Add(System.Xml.Linq.XName.Get("SimilarType", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.SimilarType));
            elementDictionary.Add(System.Xml.Linq.XName.Get("IncludeRefinementResults", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.IncludeRefinementResults));
            elementDictionary.Add(System.Xml.Linq.XName.Get("Refiners", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.Refiners));
            elementDictionary.Add(System.Xml.Linq.XName.Get("RefinementFilters", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.RefinementFilters));
            elementDictionary.Add(System.Xml.Linq.XName.Get("StartAt", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.StartAt));
            elementDictionary.Add(System.Xml.Linq.XName.Get("Count", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.Count));
            elementDictionary.Add(System.Xml.Linq.XName.Get("ImplicitAndBehavior", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.ImplicitAndBehavior));
            elementDictionary.Add(System.Xml.Linq.XName.Get("EnableStemming", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.EnableStemming));
            elementDictionary.Add(System.Xml.Linq.XName.Get("IncludeSpecialTermResults", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.IncludeSpecialTermResults));
            elementDictionary.Add(System.Xml.Linq.XName.Get("PreQuerySuggestions", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.PreQuerySuggestions));
            elementDictionary.Add(System.Xml.Linq.XName.Get("HighlightQuerySuggestions", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.HighlightQuerySuggestions));
            elementDictionary.Add(System.Xml.Linq.XName.Get("CapitalizeFirstLetters", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.CapitalizeFirstLetters));
            elementDictionary.Add(System.Xml.Linq.XName.Get("UserContextData", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.UserContextData));
            elementDictionary.Add(System.Xml.Linq.XName.Get("SimilarTo", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.SimilarTo));
            elementDictionary.Add(System.Xml.Linq.XName.Get("SortSimilar", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.SortSimilar));
            elementDictionary.Add(System.Xml.Linq.XName.Get("Refiner", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.Refiner));
            elementDictionary.Add(System.Xml.Linq.XName.Get("MaxShallowRefinementHits", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.MaxShallowRefinementHits));
            elementDictionary.Add(System.Xml.Linq.XName.Get("RefinementFilter", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.RefinementFilter));
            elementDictionary.Add(System.Xml.Linq.XName.Get("IgnoreAllNoiseQuery", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.IgnoreAllNoiseQuery));
            elementDictionary.Add(System.Xml.Linq.XName.Get("IncludeRelevantResults", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.IncludeRelevantResults));
            elementDictionary.Add(System.Xml.Linq.XName.Get("IncludeHighConfidenceResults", "urn:Microsoft.Search.Query"), typeof(global::Microsoft.Search.Query.Schemas.IncludeHighConfidenceResults));
        }
    
        private static XmlSchemaSet schemaSet;
        
        XmlSchemaSet ILinqToXsdTypeManager.Schemas {
            get {
                if ((schemaSet == null)) {
                    XmlSchemaSet tempSet = new XmlSchemaSet();
                    System.Threading.Interlocked.CompareExchange(ref schemaSet, tempSet, null);
                }
                return schemaSet;
            }
            set {
                schemaSet = value;
            }
        }
        
        protected internal static void AddSchemas(XmlSchemaSet schemas) {
            schemas.Add(schemaSet);
        }
        
        Dictionary<System.Xml.Linq.XName, System.Type> ILinqToXsdTypeManager.GlobalTypeDictionary {
            get {
                return XTypedServices.EmptyDictionary;
            }
        }
        
        Dictionary<System.Xml.Linq.XName, System.Type> ILinqToXsdTypeManager.GlobalElementDictionary {
            get {
                return elementDictionary;
            }
        }
        
        Dictionary<System.Type, System.Type> ILinqToXsdTypeManager.RootContentTypeMapping {
            get {
                return XTypedServices.EmptyTypeMappingDictionary;
            }
        }
        
        static LinqToXsdTypeManager() {
            BuildElementDictionary();
            }
        
        public static System.Type GetRootType() {
            return elementDictionary[System.Xml.Linq.XName.Get("QueryPacket", "urn:Microsoft.Search.Query")];
        }
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private static LinqToXsdTypeManager typeManagerSingleton = new LinqToXsdTypeManager();
        
        public static LinqToXsdTypeManager Instance {
            get {
                return typeManagerSingleton;
            }
        }
    }
    
    public partial class XRootNamespace {
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private XDocument doc;
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private XTypedElement rootObject;
        
        private XRootNamespace() {
        }
        
        public static XRootNamespace Load(string xmlFile) {
            XRootNamespace root = new XRootNamespace();
            root.doc = XDocument.Load(xmlFile);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public static XRootNamespace Load(string xmlFile, LoadOptions options) {
            XRootNamespace root = new XRootNamespace();
            root.doc = XDocument.Load(xmlFile, options);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public static XRootNamespace Load(TextReader textReader) {
            XRootNamespace root = new XRootNamespace();
            root.doc = XDocument.Load(textReader);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public static XRootNamespace Load(TextReader textReader, LoadOptions options) {
            XRootNamespace root = new XRootNamespace();
            root.doc = XDocument.Load(textReader, options);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public static XRootNamespace Load(XmlReader xmlReader) {
            XRootNamespace root = new XRootNamespace();
            root.doc = XDocument.Load(xmlReader);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public static XRootNamespace Parse(string text) {
            XRootNamespace root = new XRootNamespace();
            root.doc = XDocument.Parse(text);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public static XRootNamespace Parse(string text, LoadOptions options) {
            XRootNamespace root = new XRootNamespace();
            root.doc = XDocument.Parse(text, options);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public virtual void Save(string fileName) {
            doc.Save(fileName);
        }
        
        public virtual void Save(TextWriter textWriter) {
            doc.Save(textWriter);
        }
        
        public virtual void Save(XmlWriter writer) {
            doc.Save(writer);
        }
        
        public virtual void Save(TextWriter textWriter, SaveOptions options) {
            doc.Save(textWriter, options);
        }
        
        public virtual void Save(string fileName, SaveOptions options) {
            doc.Save(fileName, options);
        }
        
        public virtual XDocument XDocument {
            get {
                return doc;
            }
        }
        
        public virtual XTypedElement Root {
            get {
                return rootObject;
            }
        }
    
        public XRootNamespace(QueryPacket root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public QueryPacket QueryPacket {  get {return rootObject as QueryPacket; } }
    
        public XRootNamespace(QueryId root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public QueryId QueryId {  get {return rootObject as QueryId; } }
    
        public XRootNamespace(Context root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public Context Context {  get {return rootObject as Context; } }
    
        public XRootNamespace(QueryText root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public QueryText QueryText {  get {return rootObject as QueryText; } }
    
        public XRootNamespace(Range root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public Range Range {  get {return rootObject as Range; } }
    
        public XRootNamespace(Properties root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public Properties Properties {  get {return rootObject as Properties; } }
    
        public XRootNamespace(Property root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public Property Property {  get {return rootObject as Property; } }
    
        public XRootNamespace(SortByProperties root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public SortByProperties SortByProperties {  get {return rootObject as SortByProperties; } }
    
        public XRootNamespace(SortByProperty root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public SortByProperty SortByProperty {  get {return rootObject as SortByProperty; } }
    
        public XRootNamespace(RelevanceModel root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public RelevanceModel RelevanceModel {  get {return rootObject as RelevanceModel; } }
    
        public XRootNamespace(TrimDuplicates root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public TrimDuplicates TrimDuplicates {  get {return rootObject as TrimDuplicates; } }
    
        public XRootNamespace(ResultProvider root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public ResultProvider ResultProvider {  get {return rootObject as ResultProvider; } }
    
        public XRootNamespace(ResubmitFlags root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public ResubmitFlags ResubmitFlags {  get {return rootObject as ResubmitFlags; } }
    
        public XRootNamespace(ResubmitFlag root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public ResubmitFlag ResubmitFlag {  get {return rootObject as ResubmitFlag; } }
    
        public XRootNamespace(EnableSpellcheck root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public EnableSpellcheck EnableSpellcheck {  get {return rootObject as EnableSpellcheck; } }
    
        public XRootNamespace(UserContext root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public UserContext UserContext {  get {return rootObject as UserContext; } }
    
        public XRootNamespace(FindSimilar root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public FindSimilar FindSimilar {  get {return rootObject as FindSimilar; } }
    
        public XRootNamespace(SimilarType root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public SimilarType SimilarType {  get {return rootObject as SimilarType; } }
    
        public XRootNamespace(IncludeRefinementResults root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public IncludeRefinementResults IncludeRefinementResults {  get {return rootObject as IncludeRefinementResults; } }
    
        public XRootNamespace(Refiners root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public Refiners Refiners {  get {return rootObject as Refiners; } }
    
        public XRootNamespace(RefinementFilters root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public RefinementFilters RefinementFilters {  get {return rootObject as RefinementFilters; } }
    
        public XRootNamespace(StartAt root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public StartAt StartAt {  get {return rootObject as StartAt; } }
    
        public XRootNamespace(Count root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public Count Count {  get {return rootObject as Count; } }
    
        public XRootNamespace(ImplicitAndBehavior root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public ImplicitAndBehavior ImplicitAndBehavior {  get {return rootObject as ImplicitAndBehavior; } }
    
        public XRootNamespace(EnableStemming root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public EnableStemming EnableStemming {  get {return rootObject as EnableStemming; } }
    
        public XRootNamespace(IncludeSpecialTermResults root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public IncludeSpecialTermResults IncludeSpecialTermResults {  get {return rootObject as IncludeSpecialTermResults; } }
    
        public XRootNamespace(PreQuerySuggestions root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public PreQuerySuggestions PreQuerySuggestions {  get {return rootObject as PreQuerySuggestions; } }
    
        public XRootNamespace(HighlightQuerySuggestions root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public HighlightQuerySuggestions HighlightQuerySuggestions {  get {return rootObject as HighlightQuerySuggestions; } }
    
        public XRootNamespace(CapitalizeFirstLetters root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public CapitalizeFirstLetters CapitalizeFirstLetters {  get {return rootObject as CapitalizeFirstLetters; } }
    
        public XRootNamespace(UserContextData root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public UserContextData UserContextData {  get {return rootObject as UserContextData; } }
    
        public XRootNamespace(SimilarTo root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public SimilarTo SimilarTo {  get {return rootObject as SimilarTo; } }
    
        public XRootNamespace(SortSimilar root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public SortSimilar SortSimilar {  get {return rootObject as SortSimilar; } }
    
        public XRootNamespace(Refiner root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public Refiner Refiner {  get {return rootObject as Refiner; } }
    
        public XRootNamespace(MaxShallowRefinementHits root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public MaxShallowRefinementHits MaxShallowRefinementHits {  get {return rootObject as MaxShallowRefinementHits; } }
    
        public XRootNamespace(RefinementFilter root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public RefinementFilter RefinementFilter {  get {return rootObject as RefinementFilter; } }
    
        public XRootNamespace(IgnoreAllNoiseQuery root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public IgnoreAllNoiseQuery IgnoreAllNoiseQuery {  get {return rootObject as IgnoreAllNoiseQuery; } }
    
        public XRootNamespace(IncludeRelevantResults root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public IncludeRelevantResults IncludeRelevantResults {  get {return rootObject as IncludeRelevantResults; } }
    
        public XRootNamespace(IncludeHighConfidenceResults root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public IncludeHighConfidenceResults IncludeHighConfidenceResults {  get {return rootObject as IncludeHighConfidenceResults; } }
    }

    public partial class XRoot {
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private XDocument doc;
        
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private XTypedElement rootObject;
        
        private XRoot() {
        }
        
        public static XRoot Load(string xmlFile) {
            XRoot root = new XRoot();
            root.doc = XDocument.Load(xmlFile);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public static XRoot Load(string xmlFile, LoadOptions options) {
            XRoot root = new XRoot();
            root.doc = XDocument.Load(xmlFile, options);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public static XRoot Load(TextReader textReader) {
            XRoot root = new XRoot();
            root.doc = XDocument.Load(textReader);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public static XRoot Load(TextReader textReader, LoadOptions options) {
            XRoot root = new XRoot();
            root.doc = XDocument.Load(textReader, options);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public static XRoot Load(XmlReader xmlReader) {
            XRoot root = new XRoot();
            root.doc = XDocument.Load(xmlReader);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public static XRoot Parse(string text) {
            XRoot root = new XRoot();
            root.doc = XDocument.Parse(text);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public static XRoot Parse(string text, LoadOptions options) {
            XRoot root = new XRoot();
            root.doc = XDocument.Parse(text, options);
            XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
            if ((typedRoot == null)) {
                throw new LinqToXsdException("Invalid root element in xml document.");
            }
            root.rootObject = typedRoot;
            return root;
        }
        
        public virtual void Save(string fileName) {
            doc.Save(fileName);
        }
        
        public virtual void Save(TextWriter textWriter) {
            doc.Save(textWriter);
        }
        
        public virtual void Save(XmlWriter writer) {
            doc.Save(writer);
        }
        
        public virtual void Save(TextWriter textWriter, SaveOptions options) {
            doc.Save(textWriter, options);
        }
        
        public virtual void Save(string fileName, SaveOptions options) {
            doc.Save(fileName, options);
        }
        
        public virtual XDocument XDocument {
            get {
                return doc;
            }
        }
        
        public virtual XTypedElement Root {
            get {
                return rootObject;
            }
        }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.QueryPacket root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.QueryPacket QueryPacket {  get {return rootObject as global::Microsoft.Search.Query.Schemas.QueryPacket; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.QueryId root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.QueryId QueryId {  get {return rootObject as global::Microsoft.Search.Query.Schemas.QueryId; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.Context root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.Context Context {  get {return rootObject as global::Microsoft.Search.Query.Schemas.Context; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.QueryText root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.QueryText QueryText {  get {return rootObject as global::Microsoft.Search.Query.Schemas.QueryText; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.Range root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.Range Range {  get {return rootObject as global::Microsoft.Search.Query.Schemas.Range; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.Properties root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.Properties Properties {  get {return rootObject as global::Microsoft.Search.Query.Schemas.Properties; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.Property root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.Property Property {  get {return rootObject as global::Microsoft.Search.Query.Schemas.Property; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.SortByProperties root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.SortByProperties SortByProperties {  get {return rootObject as global::Microsoft.Search.Query.Schemas.SortByProperties; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.SortByProperty root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.SortByProperty SortByProperty {  get {return rootObject as global::Microsoft.Search.Query.Schemas.SortByProperty; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.RelevanceModel root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.RelevanceModel RelevanceModel {  get {return rootObject as global::Microsoft.Search.Query.Schemas.RelevanceModel; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.TrimDuplicates root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.TrimDuplicates TrimDuplicates {  get {return rootObject as global::Microsoft.Search.Query.Schemas.TrimDuplicates; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.ResultProvider root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.ResultProvider ResultProvider {  get {return rootObject as global::Microsoft.Search.Query.Schemas.ResultProvider; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.ResubmitFlags root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.ResubmitFlags ResubmitFlags {  get {return rootObject as global::Microsoft.Search.Query.Schemas.ResubmitFlags; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.ResubmitFlag root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.ResubmitFlag ResubmitFlag {  get {return rootObject as global::Microsoft.Search.Query.Schemas.ResubmitFlag; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.EnableSpellcheck root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.EnableSpellcheck EnableSpellcheck {  get {return rootObject as global::Microsoft.Search.Query.Schemas.EnableSpellcheck; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.UserContext root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.UserContext UserContext {  get {return rootObject as global::Microsoft.Search.Query.Schemas.UserContext; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.FindSimilar root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.FindSimilar FindSimilar {  get {return rootObject as global::Microsoft.Search.Query.Schemas.FindSimilar; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.SimilarType root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.SimilarType SimilarType {  get {return rootObject as global::Microsoft.Search.Query.Schemas.SimilarType; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.IncludeRefinementResults root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.IncludeRefinementResults IncludeRefinementResults {  get {return rootObject as global::Microsoft.Search.Query.Schemas.IncludeRefinementResults; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.Refiners root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.Refiners Refiners {  get {return rootObject as global::Microsoft.Search.Query.Schemas.Refiners; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.RefinementFilters root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.RefinementFilters RefinementFilters {  get {return rootObject as global::Microsoft.Search.Query.Schemas.RefinementFilters; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.StartAt root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.StartAt StartAt {  get {return rootObject as global::Microsoft.Search.Query.Schemas.StartAt; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.Count root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.Count Count {  get {return rootObject as global::Microsoft.Search.Query.Schemas.Count; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.ImplicitAndBehavior root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.ImplicitAndBehavior ImplicitAndBehavior {  get {return rootObject as global::Microsoft.Search.Query.Schemas.ImplicitAndBehavior; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.EnableStemming root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.EnableStemming EnableStemming {  get {return rootObject as global::Microsoft.Search.Query.Schemas.EnableStemming; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.IncludeSpecialTermResults root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.IncludeSpecialTermResults IncludeSpecialTermResults {  get {return rootObject as global::Microsoft.Search.Query.Schemas.IncludeSpecialTermResults; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.PreQuerySuggestions root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.PreQuerySuggestions PreQuerySuggestions {  get {return rootObject as global::Microsoft.Search.Query.Schemas.PreQuerySuggestions; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.HighlightQuerySuggestions root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.HighlightQuerySuggestions HighlightQuerySuggestions {  get {return rootObject as global::Microsoft.Search.Query.Schemas.HighlightQuerySuggestions; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.CapitalizeFirstLetters root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.CapitalizeFirstLetters CapitalizeFirstLetters {  get {return rootObject as global::Microsoft.Search.Query.Schemas.CapitalizeFirstLetters; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.UserContextData root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.UserContextData UserContextData {  get {return rootObject as global::Microsoft.Search.Query.Schemas.UserContextData; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.SimilarTo root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.SimilarTo SimilarTo {  get {return rootObject as global::Microsoft.Search.Query.Schemas.SimilarTo; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.SortSimilar root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.SortSimilar SortSimilar {  get {return rootObject as global::Microsoft.Search.Query.Schemas.SortSimilar; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.Refiner root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.Refiner Refiner {  get {return rootObject as global::Microsoft.Search.Query.Schemas.Refiner; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.MaxShallowRefinementHits root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.MaxShallowRefinementHits MaxShallowRefinementHits {  get {return rootObject as global::Microsoft.Search.Query.Schemas.MaxShallowRefinementHits; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.RefinementFilter root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.RefinementFilter RefinementFilter {  get {return rootObject as global::Microsoft.Search.Query.Schemas.RefinementFilter; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.IgnoreAllNoiseQuery root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.IgnoreAllNoiseQuery IgnoreAllNoiseQuery {  get {return rootObject as global::Microsoft.Search.Query.Schemas.IgnoreAllNoiseQuery; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.IncludeRelevantResults root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.IncludeRelevantResults IncludeRelevantResults {  get {return rootObject as global::Microsoft.Search.Query.Schemas.IncludeRelevantResults; } }
    
        public XRoot(global::Microsoft.Search.Query.Schemas.IncludeHighConfidenceResults root) {
            this.doc = new XDocument(root.Untyped);
            this.rootObject = root;
        }
    
    
        public global::Microsoft.Search.Query.Schemas.IncludeHighConfidenceResults IncludeHighConfidenceResults {  get {return rootObject as global::Microsoft.Search.Query.Schemas.IncludeHighConfidenceResults; } }
    }
}