47 files changed, 7072 insertions, 1679 deletions

diff --git a/.nant/local.include b/.nant/local.include
index f71e5d8..3db063b 100644
--- a/.nant/local.include
+++ b/.nant/local.include
@@ -20,6 +20,7 @@
   <delete dir="${distbindir}/.nant"/>
   <delete>
     <fileset basedir="${distbindir}">
+      <include name="BUILDING.txt"/>
       <include name="Makefile"/>
       <include name="nant-color"/>
       <include name="OpenSim.*"/>
@@ -141,6 +142,8 @@
   </exec>
   <fail message="Failures reported in unit tests." unless="${int::parse(testresult.opensim.data.mysql.tests)==0}" /> 
 
+  <delete dir="%temp%"/>
+
 </target>
 
 <target name="test-cov" depends="build">
diff --git a/CONTRIBUTORS.txt b/CONTRIBUTORS.txt
index 5b4959a..e5c8cb9 100644
--- a/CONTRIBUTORS.txt
+++ b/CONTRIBUTORS.txt
@@ -164,6 +164,7 @@ This software uses components from the following developers:
 * log4net (http://logging.apache.org/log4net/)
 * GlynnTucker.Cache (http://gtcache.sourceforge.net/)
 * NDesk.Options 0.2.1 (http://www.ndesk.org/Options)
+* Json.NET 3.5 Release 6.  The binary used is actually Newtonsoft.Json.Net20.dll for Mono 2.4 compatability (http://james.newtonking.com/projects/json-net.aspx)
 
 Some plugins are based on Cable Beach
 Cable Beach is Copyright (c) 2008 Intel Corporation
diff --git a/OpenSim/Data/MSSQL/MSSQLInventoryData.cs b/OpenSim/Data/MSSQL/MSSQLInventoryData.cs
index 1482184..c1eee8d 100644
--- a/OpenSim/Data/MSSQL/MSSQLInventoryData.cs
+++ b/OpenSim/Data/MSSQL/MSSQLInventoryData.cs
@@ -635,9 +635,9 @@ namespace OpenSim.Data.MSSQL
         /// <param name="connection">connection to the database</param>
         private void DeleteItemsInFolder(UUID folderID, SqlConnection connection)
         {
-            using (SqlCommand command = new SqlCommand("DELETE FROM inventoryitems WHERE folderID=@folderID", connection))
+            using (SqlCommand command = new SqlCommand("DELETE FROM inventoryitems WHERE parentFolderID=@parentFolderID", connection))
             {
-                command.Parameters.Add(database.CreateParameter("folderID", folderID));
+                command.Parameters.Add(database.CreateParameter("parentFolderID", folderID));
 
                 try
                 {
diff --git a/OpenSim/Data/MSSQL/MSSQLUserData.cs b/OpenSim/Data/MSSQL/MSSQLUserData.cs
index 3ef1053..7fe8ed0 100644
--- a/OpenSim/Data/MSSQL/MSSQLUserData.cs
+++ b/OpenSim/Data/MSSQL/MSSQLUserData.cs
@@ -582,8 +582,21 @@ namespace OpenSim.Data.MSSQL
         /// <param name="appearance">the appearence</param>
         override public void UpdateUserAppearance(UUID user, AvatarAppearance appearance)
         {
-            string sql = @"DELETE FROM avatarappearance WHERE owner=@owner; 
-                        INSERT INTO avatarappearance 
+            string sql = @"DELETE FROM avatarappearance WHERE owner=@owner";
+            using (AutoClosingSqlCommand cmd = database.Query(sql))
+            {
+                cmd.Parameters.Add(database.CreateParameter("@owner", appearance.Owner));
+                try
+                {
+                    cmd.ExecuteNonQuery();
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat("[USER DB] Error deleting old user appearance, error: {0}", e.Message);
+                }
+            }
+
+            sql=@"INSERT INTO avatarappearance 
                            (owner, serial, visual_params, texture, avatar_height, 
                             body_item, body_asset, skin_item, skin_asset, hair_item, 
                             hair_asset, eyes_item, eyes_asset, shirt_item, shirt_asset, 
diff --git a/OpenSim/Framework/MainServer.cs b/OpenSim/Framework/MainServer.cs
index 84cc05e..1f5f208 100644
--- a/OpenSim/Framework/MainServer.cs
+++ b/OpenSim/Framework/MainServer.cs
@@ -25,13 +25,17 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-using OpenSim.Framework.Servers.HttpServer;
 using System.Collections.Generic;
+using System.Reflection;
+using log4net;
+using OpenSim.Framework.Servers.HttpServer;
 
 namespace OpenSim.Framework
 {
     public class MainServer
     {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
         private static BaseHttpServer instance = null;
         private static Dictionary<uint, BaseHttpServer> m_Servers =
                 new Dictionary<uint, BaseHttpServer>();
@@ -53,6 +57,8 @@ namespace OpenSim.Framework
                 return m_Servers[port];
 
             m_Servers[port] = new BaseHttpServer(port);
+
+            m_log.InfoFormat("[MAIN HTTP SERVER]: Starting main http server on port {0}", port);
             m_Servers[port].Start();
 
             return m_Servers[port];
diff --git a/OpenSim/Framework/SLUtil.cs b/OpenSim/Framework/SLUtil.cs
new file mode 100644
index 0000000..ff5f8b9
--- /dev/null
+++ b/OpenSim/Framework/SLUtil.cs
@@ -0,0 +1,282 @@
+using System;
+using System.Collections.Generic;
+using OpenMetaverse;
+
+namespace OpenSim.Framework
+{
+    public static class SLUtil
+    {
+        #region SL / file extension / content-type conversions
+
+        public static string SLAssetTypeToContentType(int assetType)
+        {
+            switch ((AssetType)assetType)
+            {
+                case AssetType.Texture:
+                    return "image/x-j2c";
+                case AssetType.Sound:
+                    return "application/ogg";
+                case AssetType.CallingCard:
+                    return "application/vnd.ll.callingcard";
+                case AssetType.Landmark:
+                    return "application/vnd.ll.landmark";
+                case AssetType.Clothing:
+                    return "application/vnd.ll.clothing";
+                case AssetType.Object:
+                    return "application/vnd.ll.primitive";
+                case AssetType.Notecard:
+                    return "application/vnd.ll.notecard";
+                case AssetType.Folder:
+                    return "application/vnd.ll.folder";
+                case AssetType.RootFolder:
+                    return "application/vnd.ll.rootfolder";
+                case AssetType.LSLText:
+                    return "application/vnd.ll.lsltext";
+                case AssetType.LSLBytecode:
+                    return "application/vnd.ll.lslbyte";
+                case AssetType.TextureTGA:
+                case AssetType.ImageTGA:
+                    return "image/tga";
+                case AssetType.Bodypart:
+                    return "application/vnd.ll.bodypart";
+                case AssetType.TrashFolder:
+                    return "application/vnd.ll.trashfolder";
+                case AssetType.SnapshotFolder:
+                    return "application/vnd.ll.snapshotfolder";
+                case AssetType.LostAndFoundFolder:
+                    return "application/vnd.ll.lostandfoundfolder";
+                case AssetType.SoundWAV:
+                    return "audio/x-wav";
+                case AssetType.ImageJPEG:
+                    return "image/jpeg";
+                case AssetType.Animation:
+                    return "application/vnd.ll.animation";
+                case AssetType.Gesture:
+                    return "application/vnd.ll.gesture";
+                case AssetType.Simstate:
+                    return "application/x-metaverse-simstate";
+                case AssetType.Unknown:
+                default:
+                    return "application/octet-stream";
+            }
+        }
+
+        public static sbyte ContentTypeToSLAssetType(string contentType)
+        {
+            switch (contentType)
+            {
+                case "image/x-j2c":
+                case "image/jp2":
+                    return (sbyte)AssetType.Texture;
+                case "application/ogg":
+                    return (sbyte)AssetType.Sound;
+                case "application/vnd.ll.callingcard":
+                case "application/x-metaverse-callingcard":
+                    return (sbyte)AssetType.CallingCard;
+                case "application/vnd.ll.landmark":
+                case "application/x-metaverse-landmark":
+                    return (sbyte)AssetType.Landmark;
+                case "application/vnd.ll.clothing":
+                case "application/x-metaverse-clothing":
+                    return (sbyte)AssetType.Clothing;
+                case "application/vnd.ll.primitive":
+                case "application/x-metaverse-primitive":
+                    return (sbyte)AssetType.Object;
+                case "application/vnd.ll.notecard":
+                case "application/x-metaverse-notecard":
+                    return (sbyte)AssetType.Notecard;
+                case "application/vnd.ll.folder":
+                    return (sbyte)AssetType.Folder;
+                case "application/vnd.ll.rootfolder":
+                    return (sbyte)AssetType.RootFolder;
+                case "application/vnd.ll.lsltext":
+                case "application/x-metaverse-lsl":
+                    return (sbyte)AssetType.LSLText;
+                case "application/vnd.ll.lslbyte":
+                case "application/x-metaverse-lso":
+                    return (sbyte)AssetType.LSLBytecode;
+                case "image/tga":
+                    // Note that AssetType.TextureTGA will be converted to AssetType.ImageTGA
+                    return (sbyte)AssetType.ImageTGA;
+                case "application/vnd.ll.bodypart":
+                case "application/x-metaverse-bodypart":
+                    return (sbyte)AssetType.Bodypart;
+                case "application/vnd.ll.trashfolder":
+                    return (sbyte)AssetType.TrashFolder;
+                case "application/vnd.ll.snapshotfolder":
+                    return (sbyte)AssetType.SnapshotFolder;
+                case "application/vnd.ll.lostandfoundfolder":
+                    return (sbyte)AssetType.LostAndFoundFolder;
+                case "audio/x-wav":
+                    return (sbyte)AssetType.SoundWAV;
+                case "image/jpeg":
+                    return (sbyte)AssetType.ImageJPEG;
+                case "application/vnd.ll.animation":
+                case "application/x-metaverse-animation":
+                    return (sbyte)AssetType.Animation;
+                case "application/vnd.ll.gesture":
+                case "application/x-metaverse-gesture":
+                    return (sbyte)AssetType.Gesture;
+                case "application/x-metaverse-simstate":
+                    return (sbyte)AssetType.Simstate;
+                case "application/octet-stream":
+                default:
+                    return (sbyte)AssetType.Unknown;
+            }
+        }
+
+        public static sbyte ContentTypeToSLInvType(string contentType)
+        {
+            switch (contentType)
+            {
+                case "image/x-j2c":
+                case "image/jp2":
+                case "image/tga":
+                case "image/jpeg":
+                    return (sbyte)InventoryType.Texture;
+                case "application/ogg":
+                case "audio/x-wav":
+                    return (sbyte)InventoryType.Sound;
+                case "application/vnd.ll.callingcard":
+                case "application/x-metaverse-callingcard":
+                    return (sbyte)InventoryType.CallingCard;
+                case "application/vnd.ll.landmark":
+                case "application/x-metaverse-landmark":
+                    return (sbyte)InventoryType.Landmark;
+                case "application/vnd.ll.clothing":
+                case "application/x-metaverse-clothing":
+                case "application/vnd.ll.bodypart":
+                case "application/x-metaverse-bodypart":
+                    return (sbyte)InventoryType.Wearable;
+                case "application/vnd.ll.primitive":
+                case "application/x-metaverse-primitive":
+                    return (sbyte)InventoryType.Object;
+                case "application/vnd.ll.notecard":
+                case "application/x-metaverse-notecard":
+                    return (sbyte)InventoryType.Notecard;
+                case "application/vnd.ll.folder":
+                    return (sbyte)InventoryType.Folder;
+                case "application/vnd.ll.rootfolder":
+                    return (sbyte)InventoryType.RootCategory;
+                case "application/vnd.ll.lsltext":
+                case "application/x-metaverse-lsl":
+                case "application/vnd.ll.lslbyte":
+                case "application/x-metaverse-lso":
+                    return (sbyte)InventoryType.LSL;
+                case "application/vnd.ll.trashfolder":
+                case "application/vnd.ll.snapshotfolder":
+                case "application/vnd.ll.lostandfoundfolder":
+                    return (sbyte)InventoryType.Folder;
+                case "application/vnd.ll.animation":
+                case "application/x-metaverse-animation":
+                    return (sbyte)InventoryType.Animation;
+                case "application/vnd.ll.gesture":
+                case "application/x-metaverse-gesture":
+                    return (sbyte)InventoryType.Gesture;
+                case "application/x-metaverse-simstate":
+                    return (sbyte)InventoryType.Snapshot;
+                case "application/octet-stream":
+                default:
+                    return (sbyte)InventoryType.Unknown;
+            }
+        }
+
+        #endregion SL / file extension / content-type conversions
+
+        /// <summary>
+        /// Parse a notecard in Linden format to a string of ordinary text.
+        /// </summary>
+        /// <param name="rawInput"></param>
+        /// <returns></returns>        
+        public static string ParseNotecardToString(string rawInput)
+        {
+            return string.Join("\n", ParseNotecardToList(rawInput).ToArray());
+        }
+                
+        /// <summary>
+        /// Parse a notecard in Linden format to a list of ordinary lines.
+        /// </summary>
+        /// <param name="rawInput"></param>
+        /// <returns></returns>
+        public static List<string> ParseNotecardToList(string rawInput)
+        {
+            string[] input = rawInput.Replace("\r", "").Split('\n');            
+            int idx = 0;
+            int level = 0;
+            List<string> output = new List<string>();
+            string[] words;
+
+            while (idx < input.Length)
+            {
+                if (input[idx] == "{")
+                {
+                    level++;
+                    idx++;
+                    continue;
+                }
+
+                if (input[idx]== "}")
+                {
+                    level--;
+                    idx++;
+                    continue;
+                }
+
+                switch (level)
+                {
+                case 0:
+                    words = input[idx].Split(' '); // Linden text ver
+                    // Notecards are created *really* empty. Treat that as "no text" (just like after saving an empty notecard)
+                    if (words.Length < 3)
+                        return output;
+
+                    int version = int.Parse(words[3]);
+                    if (version != 2)
+                        return output;
+                    break;
+                case 1:
+                    words = input[idx].Split(' ');
+                    if (words[0] == "LLEmbeddedItems")
+                        break;
+                    if (words[0] == "Text")
+                    {
+                        int len = int.Parse(words[2]);
+                        idx++;
+
+                        int count = -1;
+
+                        while (count < len)
+                        {
+                            // int l = input[idx].Length;
+                            string ln = input[idx];
+
+                            int need = len-count-1;
+                            if (ln.Length > need)
+                                ln = ln.Substring(0, need);
+
+                            output.Add(ln);
+                            count += ln.Length + 1;
+                            idx++;
+                        }
+
+                        return output;
+                    }
+                    break;
+                case 2:
+                    words = input[idx].Split(' '); // count
+                    if (words[0] == "count")
+                    {
+                        int c = int.Parse(words[1]);
+                        if (c > 0)
+                            return output;
+                        break;
+                    }
+                    break;
+                }
+                idx++;
+            }
+            
+            return output;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Framework/Serialization/TarArchiveWriter.cs b/OpenSim/Framework/Serialization/TarArchiveWriter.cs
index 20d0f7e..0bd639f 100644
--- a/OpenSim/Framework/Serialization/TarArchiveWriter.cs
+++ b/OpenSim/Framework/Serialization/TarArchiveWriter.cs
@@ -208,7 +208,9 @@ namespace OpenSim.Framework.Serialization
                 m_bw.Write(header);
     
                 // Write out data
-                m_bw.Write(data);
+                // An IOException occurs if we try to write out an empty array in Mono 2.6
+                if (data.Length > 0)
+                    m_bw.Write(data);
     
                 if (data.Length % 512 != 0)
                 {
diff --git a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
index 214f936..297d047 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
@@ -311,7 +311,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             }
             catch (Exception e)
             {
-                m_log.ErrorFormat("[BASE HTTP SERVER]: OnRequest() failed with {0} {1}", e.Message, e.StackTrace);
+                m_log.Error(string.Format("[BASE HTTP SERVER]: OnRequest() failed with "), e);
             }
         }
 
@@ -1572,7 +1572,6 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         public void Start()
         {
-            m_log.Info("[BASE HTTP SERVER]: Starting up HTTP Server");
             StartHTTP();
         }
 
@@ -1580,7 +1579,6 @@ namespace OpenSim.Framework.Servers.HttpServer
         {
             try
             {
-                m_log.Debug("[BASE HTTP SERVER]: Spawned main thread OK");
                 //m_httpListener = new HttpListener();
                 NotSocketErrors = 0;
                 if (!m_ssl)
diff --git a/OpenSim/Framework/Servers/VersionInfo.cs b/OpenSim/Framework/Servers/VersionInfo.cs
index 1ae493d..fb41ef3 100644
--- a/OpenSim/Framework/Servers/VersionInfo.cs
+++ b/OpenSim/Framework/Servers/VersionInfo.cs
@@ -30,7 +30,7 @@ namespace OpenSim
     public class VersionInfo
     {
         private const string VERSION_NUMBER = "0.6.9";
-        private const Flavour VERSION_FLAVOUR = Flavour.Release;
+        private const Flavour VERSION_FLAVOUR = Flavour.Post_Fixes;
 
         public enum Flavour
         {
diff --git a/OpenSim/Region/Application/ConfigurationLoader.cs b/OpenSim/Region/Application/ConfigurationLoader.cs
index 21edcc5..da77a2b 100644
--- a/OpenSim/Region/Application/ConfigurationLoader.cs
+++ b/OpenSim/Region/Application/ConfigurationLoader.cs
@@ -164,12 +164,12 @@ namespace OpenSim
             m_config.Source = new IniConfigSource();
             m_config.Source.Merge(DefaultConfig());
 
-            m_log.Info("[CONFIG] Reading configuration settings");
+            m_log.Info("[CONFIG]: Reading configuration settings");
 
             if (sources.Count == 0)
             {
-                m_log.FatalFormat("[CONFIG] Could not load any configuration");
-                m_log.FatalFormat("[CONFIG] Did you copy the OpenSim.ini.example file to OpenSim.ini?");
+                m_log.FatalFormat("[CONFIG]: Could not load any configuration");
+                m_log.FatalFormat("[CONFIG]: Did you copy the OpenSim.ini.example file to OpenSim.ini?");
                 Environment.Exit(1);
             }
 
@@ -182,8 +182,8 @@ namespace OpenSim
 
             if (!iniFileExists)
             {
-                m_log.FatalFormat("[CONFIG] Could not load any configuration");
-                m_log.FatalFormat("[CONFIG] Configuration exists, but there was an error loading it!");
+                m_log.FatalFormat("[CONFIG]: Could not load any configuration");
+                m_log.FatalFormat("[CONFIG]: Configuration exists, but there was an error loading it!");
                 Environment.Exit(1);
             }
 
@@ -257,20 +257,17 @@ namespace OpenSim
 
             if (!IsUri(iniPath))
             {
-                m_log.InfoFormat("[CONFIG] Reading configuration file {0}",
-                        Path.GetFullPath(iniPath));
+                m_log.InfoFormat("[CONFIG]: Reading configuration file {0}", Path.GetFullPath(iniPath));
 
                 m_config.Source.Merge(new IniConfigSource(iniPath));
                 success = true;
             }
             else
             {
-                m_log.InfoFormat("[CONFIG] {0} is a http:// URI, fetching ...",
-                        iniPath);
+                m_log.InfoFormat("[CONFIG]: {0} is a http:// URI, fetching ...", iniPath);
 
                 // The ini file path is a http URI
                 // Try to read it
-                //
                 try
                 {
                     XmlReader r = XmlReader.Create(iniPath);
@@ -281,7 +278,7 @@ namespace OpenSim
                 }
                 catch (Exception e)
                 {
-                    m_log.FatalFormat("[CONFIG] Exception reading config from URI {0}\n" + e.ToString(), iniPath);
+                    m_log.FatalFormat("[CONFIG]: Exception reading config from URI {0}\n" + e.ToString(), iniPath);
                     Environment.Exit(1);
                 }
             }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
index 2ab713d..724c8bc 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
@@ -348,6 +348,23 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         protected PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock> m_avatarTerseUpdates;
         private PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock> m_primTerseUpdates;
         private PriorityQueue<double, ObjectUpdatePacket.ObjectDataBlock> m_primFullUpdates;
+
+        /// <value>
+        /// List used in construction of data blocks for an object update packet.  This is to stop us having to
+        /// continually recreate it.
+        /// </value>
+        protected List<ObjectUpdatePacket.ObjectDataBlock> m_fullUpdateDataBlocksBuilder;
+
+        /// <value>
+        /// Maintain a record of all the objects killed.  This allows us to stop an update being sent from the
+        /// thread servicing the m_primFullUpdates queue after a kill.  If this happens the object persists as an
+        /// ownerless phantom.
+        ///
+        /// All manipulation of this set has to occur under a m_primFullUpdate.SyncRoot lock
+        ///       
+        /// </value>
+        protected HashSet<uint> m_killRecord;
+        
         private int m_moneyBalance;
         private int m_animationSequenceNumber = 1;
         private bool m_SendLogoutPacketWhenClosing = true;
@@ -437,6 +454,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             m_avatarTerseUpdates = new PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock>();
             m_primTerseUpdates = new PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock>();
             m_primFullUpdates = new PriorityQueue<double, ObjectUpdatePacket.ObjectDataBlock>(m_scene.Entities.Count);
+            m_fullUpdateDataBlocksBuilder = new List<ObjectUpdatePacket.ObjectDataBlock>();
+            m_killRecord = new HashSet<uint>();
 
             m_assetService = m_scene.RequestModuleInterface<IAssetService>();
             m_hyperAssets = m_scene.RequestModuleInterface<IHyperAssetService>();
@@ -1476,7 +1495,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             kill.ObjectData[0].ID = localID;
             kill.Header.Reliable = true;
             kill.Header.Zerocoded = true;
-            OutPacket(kill, ThrottleOutPacketType.State);
+
+            lock (m_primFullUpdates.SyncRoot)
+            {
+                m_killRecord.Add(localID);
+                OutPacket(kill, ThrottleOutPacketType.State);
+            }
         }
 
         /// <summary>
@@ -3518,21 +3542,34 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 if (count == 0)
                     return;
 
-                outPacket.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[count];
+                m_fullUpdateDataBlocksBuilder.Clear();
+                                
                 for (int i = 0; i < count; i++)
                 {
-                    outPacket.ObjectData[i] = m_primFullUpdates.Dequeue();
+                    ObjectUpdatePacket.ObjectDataBlock block = m_primFullUpdates.Dequeue();
 
+                    if (!m_killRecord.Contains(block.ID))
+                    {
+                        m_fullUpdateDataBlocksBuilder.Add(block);
+                        
 //                    string text = Util.FieldToString(outPacket.ObjectData[i].Text);
 //                    if (text.IndexOf("\n") >= 0)
 //                        text = text.Remove(text.IndexOf("\n"));
 //                    m_log.DebugFormat(
 //                        "[CLIENT]: Sending full info about prim {0} text {1} to client {2}", 
 //                        outPacket.ObjectData[i].ID, text, Name);
+                    }
+//                    else
+//                    {
+//                        m_log.WarnFormat(
+//                            "[CLIENT]: Preventing full update for {0} after kill to {1}", block.ID, Name);                        
+//                    }
                 }
-            }
 
-            OutPacket(outPacket, ThrottleOutPacketType.State);
+                outPacket.ObjectData = m_fullUpdateDataBlocksBuilder.ToArray();
+                
+                OutPacket(outPacket, ThrottleOutPacketType.State);
+            }            
         }
 
         public void SendPrimTerseUpdate(SendPrimitiveTerseData data)
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
index 3c4fa72..5ed4cd7 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
@@ -513,6 +513,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             byte flags = buffer.Data[0];
             bool isResend = (flags & Helpers.MSG_RESENT) != 0;
             bool isReliable = (flags & Helpers.MSG_RELIABLE) != 0;
+            bool isZerocoded = (flags & Helpers.MSG_ZEROCODED) != 0;
             LLUDPClient udpClient = outgoingPacket.Client;
 
             if (!udpClient.IsConnected)
@@ -522,23 +523,27 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             int dataLength = buffer.DataLength;
 
-            // Keep appending ACKs until there is no room left in the buffer or there are
-            // no more ACKs to append
-            uint ackCount = 0;
-            uint ack;
-            while (dataLength + 5 < buffer.Data.Length && udpClient.PendingAcks.Dequeue(out ack))
+            // NOTE: I'm seeing problems with some viewers when ACKs are appended to zerocoded packets so I've disabled that here
+            if (!isZerocoded)
             {
-                Utils.UIntToBytesBig(ack, buffer.Data, dataLength);
-                dataLength += 4;
-                ++ackCount;
-            }
+                // Keep appending ACKs until there is no room left in the buffer or there are
+                // no more ACKs to append
+                uint ackCount = 0;
+                uint ack;
+                while (dataLength + 5 < buffer.Data.Length && udpClient.PendingAcks.Dequeue(out ack))
+                {
+                    Utils.UIntToBytesBig(ack, buffer.Data, dataLength);
+                    dataLength += 4;
+                    ++ackCount;
+                }
 
-            if (ackCount > 0)
-            {
-                // Set the last byte of the packet equal to the number of appended ACKs
-                buffer.Data[dataLength++] = (byte)ackCount;
-                // Set the appended ACKs flag on this packet
-                buffer.Data[0] = (byte)(buffer.Data[0] | Helpers.MSG_APPENDED_ACKS);
+                if (ackCount > 0)
+                {
+                    // Set the last byte of the packet equal to the number of appended ACKs
+                    buffer.Data[dataLength++] = (byte)ackCount;
+                    // Set the appended ACKs flag on this packet
+                    buffer.Data[0] = (byte)(buffer.Data[0] | Helpers.MSG_APPENDED_ACKS);
+                }
             }
 
             buffer.DataLength = dataLength;
diff --git a/OpenSim/Region/ClientStack/RegionApplicationBase.cs b/OpenSim/Region/ClientStack/RegionApplicationBase.cs
index c7aeca14..e57e298 100644
--- a/OpenSim/Region/ClientStack/RegionApplicationBase.cs
+++ b/OpenSim/Region/ClientStack/RegionApplicationBase.cs
@@ -105,10 +105,10 @@ namespace OpenSim.Region.ClientStack
             
             if (m_networkServersInfo.HttpUsesSSL && (m_networkServersInfo.HttpListenerPort == m_networkServersInfo.httpSSLPort))
             {
-                m_log.Error("[HTTP]: HTTP Server config failed.   HTTP Server and HTTPS server must be on different ports");
+                m_log.Error("[REGION SERVER]: HTTP Server config failed.   HTTP Server and HTTPS server must be on different ports");
             }
 
-            m_log.Info("[REGION]: Starting HTTP server");
+            m_log.InfoFormat("[REGION SERVER]: Starting HTTP server on port {0}", m_httpServerPort);
             m_httpServer.Start();
 
             base.StartupSpecific();
@@ -134,4 +134,4 @@ namespace OpenSim.Region.ClientStack
             return physicsPluginManager.GetPhysicsScene(engine, meshEngine, config, osSceneIdentifier);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Avatar/Dialog/DialogModule.cs b/OpenSim/Region/CoreModules/Avatar/Dialog/DialogModule.cs
index 72ec869..6a9a962 100644
--- a/OpenSim/Region/CoreModules/Avatar/Dialog/DialogModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Dialog/DialogModule.cs
@@ -79,7 +79,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Dialog
         {
             ScenePresence sp = m_scene.GetScenePresence(agentID);
             
-            if (sp != null)
+            if (sp != null && !sp.IsChildAgent)
                 sp.ControllingClient.SendAgentAlertMessage(message, modal);
         }
         
@@ -91,7 +91,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Dialog
             {
                 ScenePresence presence = presenceList[i];
 
-                if (presence.Firstname == firstName && presence.Lastname == lastName)
+                if (!presence.IsChildAgent && presence.Firstname == firstName && presence.Lastname == lastName)
                 {
                     presence.ControllingClient.SendAgentAlertMessage(message, modal);
                     break;
@@ -130,7 +130,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Dialog
             }
 
             ScenePresence sp = m_scene.GetScenePresence(avatarID);
-            if (sp != null)
+            if (sp != null && !sp.IsChildAgent)
                 sp.ControllingClient.SendDialog(objectName, objectID, ownerFirstName, ownerLastName, message, textureID, ch, buttonlabels);
         }
 
@@ -139,7 +139,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Dialog
         {
             ScenePresence sp = m_scene.GetScenePresence(avatarID);
             
-            if (sp != null)
+            if (sp != null && !sp.IsChildAgent)
                 sp.ControllingClient.SendLoadURL(objectName, objectID, ownerID, groupOwned, message, url);
         }
         
@@ -206,4 +206,4 @@ namespace OpenSim.Region.CoreModules.Avatar.Dialog
             return result;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Scripting/XMLRPC/XMLRPCModule.cs b/OpenSim/Region/CoreModules/Scripting/XMLRPC/XMLRPCModule.cs
index 27b64bf..40ffcb4 100644
--- a/OpenSim/Region/CoreModules/Scripting/XMLRPC/XMLRPCModule.cs
+++ b/OpenSim/Region/CoreModules/Scripting/XMLRPC/XMLRPCModule.cs
@@ -131,8 +131,8 @@ namespace OpenSim.Region.CoreModules.Scripting.XMLRPC
             {
                 // Start http server
                 // Attach xmlrpc handlers
-                m_log.Info("[REMOTE_DATA]: " +
-                           "Starting XMLRPC Server on port " + m_remoteDataPort + " for llRemoteData commands.");
+                m_log.Info("[XML RPC MODULE]: " +
+                           "Starting up XMLRPC Server on port " + m_remoteDataPort + " for llRemoteData commands.");
                 BaseHttpServer httpServer = new BaseHttpServer((uint) m_remoteDataPort);
                 httpServer.AddXmlRPCHandler("llRemoteData", XmlRpcRemoteData);
                 httpServer.Start();
@@ -192,7 +192,7 @@ namespace OpenSim.Region.CoreModules.Scripting.XMLRPC
             // This should no longer happen, but the check is reasonable anyway
             if (null == m_openChannels)
             {
-                m_log.Warn("[RemoteDataReply] Attempt to open channel before initialization is complete");
+                m_log.Warn("[XML RPC MODULE]: Attempt to open channel before initialization is complete");
                 return newChannel;
             }
 
@@ -279,7 +279,7 @@ namespace OpenSim.Region.CoreModules.Scripting.XMLRPC
             }
             else
             {
-                m_log.Warn("[RemoteDataReply]: Channel or message_id not found");
+                m_log.Warn("[XML RPC MODULE]: Channel or message_id not found");
             }
         }
 
@@ -340,7 +340,7 @@ namespace OpenSim.Region.CoreModules.Scripting.XMLRPC
                 }
                 else
                 {
-                    m_log.Error("UNABLE TO REMOVE COMPLETED REQUEST");
+                    m_log.Error("[XML RPC MODULE]: UNABLE TO REMOVE COMPLETED REQUEST");
                 }
             }
         }
@@ -728,4 +728,4 @@ namespace OpenSim.Region.CoreModules.Scripting.XMLRPC
             return ReqID;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Interregion/LocalInterregionComms.cs b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Interregion/LocalInterregionComms.cs
index d68c683..4abc215 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Interregion/LocalInterregionComms.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Interregion/LocalInterregionComms.cs
@@ -260,7 +260,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Interregion
             {
                 if (s.RegionInfo.RegionHandle == regionHandle)
                 {
-                    //m_log.Debug("[LOCAL COMMS]: Found region to SendCreateObject");
+                    m_log.Debug("[LOCAL COMMS]: Found region to SendCreateObject");
                     if (isLocalCall)
                     {
                         // We need to make a local copy of the object
diff --git a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Inventory/LocalInventoryServiceConnector.cs b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Inventory/LocalInventoryServiceConnector.cs
index 191e859..cabd51c 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Inventory/LocalInventoryServiceConnector.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Inventory/LocalInventoryServiceConnector.cs
@@ -314,10 +314,13 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory
         {
 //            m_log.DebugFormat("[LOCAL INVENTORY SERVICES CONNECTOR]: Requesting inventory item {0}", item.ID);
 
+            UUID requestedItemId = item.ID;
+            
             item = m_InventoryService.GetItem(item);
 
             if (null == item)
-                m_log.ErrorFormat("[LOCAL INVENTORY SERVICES CONNECTOR]: Could not find item with id {0}", item.ID);
+                m_log.ErrorFormat(
+                    "[LOCAL INVENTORY SERVICES CONNECTOR]: Could not find item with id {0}", requestedItemId);
 
             return item;
         }
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
index 381c8f7..2e30e09 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
@@ -276,7 +276,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                     }
                 }
 
-                if (m_scene.AddRestoredSceneObject(sceneObject, true, false))
+                if (!m_scene.AddRestoredSceneObject(sceneObject, true, false))
                 {
                     sceneObjectsLoadedCount++;
                     sceneObject.CreateScriptInstances(0, false, m_scene.DefaultScriptEngine, 0);
diff --git a/OpenSim/Region/Framework/Interfaces/IGroupsMessagingModule.cs b/OpenSim/Region/Framework/Interfaces/IGroupsMessagingModule.cs
new file mode 100644
index 0000000..f158236
--- /dev/null
+++ b/OpenSim/Region/Framework/Interfaces/IGroupsMessagingModule.cs
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using OpenMetaverse;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.Framework.Interfaces
+{
+    /// <summary>
+    /// Provide mechanisms for messaging groups.
+    /// </summary>
+    /// 
+    /// TODO: Provide a mechanism for receiving group messages as well as sending them
+    /// 
+    public interface IGroupsMessagingModule
+    {
+        /// <summary>
+        /// Start a group chat session.
+        /// </summary>
+        /// You must call this before calling SendMessageToGroup().  If a chat session for this group is already taking
+        /// place then the agent will added to that session.
+        /// <param name="agentID">
+        /// A UUID that represents the agent being added.  If you are agentless (e.g. you are
+        /// a region module), then you can use any random ID.
+        /// </param>
+        /// <param name="groupID">
+        /// The ID for the group to join.  Currently, the session ID used is identical to the
+        /// group ID.
+        /// </param>
+        /// <returns>
+        /// True if the chat session was started successfully, false otherwise.
+        /// </returns>
+        bool StartGroupChatSession(UUID agentID, UUID groupID);
+        
+        /// <summary>
+        /// Send a message to an entire group.
+        /// </summary>
+        /// <param name="im">
+        /// The message itself.  The fields that must be populated are
+        /// 
+        /// imSessionID - Populate this with the group ID (session ID and group ID are currently identical)
+        /// fromAgentName - Populate this with whatever arbitrary name you want to show up in the chat dialog
+        /// message - The message itself
+        /// dialog - This must be (byte)InstantMessageDialog.SessionSend
+        /// </param>
+        /// <param name="groupID"></param>
+        void SendMessageToGroup(GridInstantMessage im, UUID groupID);
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/IGroupsModule.cs b/OpenSim/Region/Framework/Interfaces/IGroupsModule.cs
index 8980b2d..9683da0 100644
--- a/OpenSim/Region/Framework/Interfaces/IGroupsModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IGroupsModule.cs
@@ -37,6 +37,37 @@ namespace OpenSim.Region.Framework.Interfaces
     {
         event NewGroupNotice OnNewGroupNotice;
 
+        /// <summary>
+        /// Create a group
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="name"></param>
+        /// <param name="charter"></param>
+        /// <param name="showInList"></param>
+        /// <param name="insigniaID"></param>
+        /// <param name="membershipFee"></param>
+        /// <param name="openEnrollment"></param>
+        /// <param name="allowPublish"></param>
+        /// <param name="maturePublish"></param>
+        /// <returns>The UUID of the created group</returns>
+        UUID CreateGroup(
+            IClientAPI remoteClient, string name, string charter, bool showInList, UUID insigniaID, int membershipFee, 
+            bool openEnrollment, bool allowPublish, bool maturePublish);
+
+        /// <summary>
+        /// Get a group
+        /// </summary>
+        /// <param name="name">Name of the group</param>
+        /// <returns>The group's data.  Null if there is no such group.</returns>
+        GroupRecord GetGroupRecord(string name);
+
+        /// <summary>
+        /// Get a group
+        /// </summary>
+        /// <param name="GroupID">ID of the group</param>
+        /// <returns>The group's data.  Null if there is no such group.</returns>        
+        GroupRecord GetGroupRecord(UUID GroupID);
+        
         void ActivateGroup(IClientAPI remoteClient, UUID groupID);
         List<GroupTitlesData> GroupTitlesRequest(IClientAPI remoteClient, UUID groupID);
         List<GroupMembersData> GroupMembersRequest(IClientAPI remoteClient, UUID groupID);
@@ -51,7 +82,6 @@ namespace OpenSim.Region.Framework.Interfaces
         void SetGroupAcceptNotices(IClientAPI remoteClient, UUID groupID, bool acceptNotices, bool listInProfile);
 
         void GroupTitleUpdate(IClientAPI remoteClient, UUID GroupID, UUID TitleRoleID);
-        UUID CreateGroup(IClientAPI remoteClient, string name, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish);
         
         GroupNoticeData[] GroupNoticesListRequest(IClientAPI remoteClient, UUID GroupID);
         string GetGroupTitle(UUID avatarID);
@@ -64,7 +94,6 @@ namespace OpenSim.Region.Framework.Interfaces
         void LeaveGroupRequest(IClientAPI remoteClient, UUID GroupID);
         void EjectGroupMemberRequest(IClientAPI remoteClient, UUID GroupID, UUID EjecteeID);
         void InviteGroupRequest(IClientAPI remoteClient, UUID GroupID, UUID InviteeID, UUID RoleID);
-        GroupRecord GetGroupRecord(UUID GroupID);
         void NotifyChange(UUID GroupID);
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index 57e1c37..4365ece 100644
--- a/OpenSim/Region/Framework/Scenes/EventManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EventManager.cs
@@ -107,21 +107,24 @@ namespace OpenSim.Region.Framework.Scenes
         public event OnSetRootAgentSceneDelegate OnSetRootAgentScene;
 
         /// <summary>
-        /// Called when an object is touched/grabbed.
+        /// Fired when an object is touched/grabbed.
         /// </summary>
         /// The originalID is the local ID of the part that was actually touched.  The localID itself is always that of
-        /// the root part.
-        public delegate void ObjectGrabDelegate(uint localID, uint originalID, Vector3 offsetPos, IClientAPI remoteClient, SurfaceTouchEventArgs surfaceArgs);
+        /// the root part.        
         public event ObjectGrabDelegate OnObjectGrab;
+        public delegate void ObjectGrabDelegate(uint localID, uint originalID, Vector3 offsetPos, IClientAPI remoteClient, SurfaceTouchEventArgs surfaceArgs);        
         
         public event ObjectGrabDelegate OnObjectGrabbing;
         public event ObjectDeGrabDelegate OnObjectDeGrab;
         public event ScriptResetDelegate OnScriptReset;
 
-        public event OnPermissionErrorDelegate OnPermissionError;
+        public event OnPermissionErrorDelegate OnPermissionError;        
 
-        public delegate void NewRezScript(uint localID, UUID itemID, string script, int startParam, bool postOnRez, string engine, int stateSource);
+        /// <summary>
+        /// Fired when a new script is created.
+        /// </summary>
         public event NewRezScript OnRezScript;
+        public delegate void NewRezScript(uint localID, UUID itemID, string script, int startParam, bool postOnRez, string engine, int stateSource);
 
         public delegate void RemoveScript(uint localID, UUID itemID);
         public event RemoveScript OnRemoveScript;
@@ -163,38 +166,35 @@ namespace OpenSim.Region.Framework.Scenes
 
         public delegate void ClientClosed(UUID clientID, Scene scene);
 
-        public event ClientClosed OnClientClosed;
-
-        public delegate void ScriptChangedEvent(uint localID, uint change);
+        public event ClientClosed OnClientClosed;        
 
+        /// <summary>
+        /// This is fired when a scene object property that a script might be interested in (such as color, scale or
+        /// inventory) changes.  Only enough information is sent for the LSL changed event
+        /// (see http://lslwiki.net/lslwiki/wakka.php?wakka=changed)
+        /// </summary>
         public event ScriptChangedEvent OnScriptChangedEvent;
+        public delegate void ScriptChangedEvent(uint localID, uint change);
 
         public delegate void ScriptControlEvent(uint localID, UUID item, UUID avatarID, uint held, uint changed);
-
         public event ScriptControlEvent OnScriptControlEvent;
 
         public delegate void ScriptAtTargetEvent(uint localID, uint handle, Vector3 targetpos, Vector3 atpos);
-
         public event ScriptAtTargetEvent OnScriptAtTargetEvent;
 
         public delegate void ScriptNotAtTargetEvent(uint localID);
-
         public event ScriptNotAtTargetEvent OnScriptNotAtTargetEvent;
 
         public delegate void ScriptAtRotTargetEvent(uint localID, uint handle, Quaternion targetrot, Quaternion atrot);
-
         public event ScriptAtRotTargetEvent OnScriptAtRotTargetEvent;
 
         public delegate void ScriptNotAtRotTargetEvent(uint localID);
-
         public event ScriptNotAtRotTargetEvent OnScriptNotAtRotTargetEvent;
 
         public delegate void ScriptColliding(uint localID, ColliderArgs colliders);
-
         public event ScriptColliding OnScriptColliderStart;
         public event ScriptColliding OnScriptColliding;
         public event ScriptColliding OnScriptCollidingEnd;
-
         public event ScriptColliding OnScriptLandColliderStart;
         public event ScriptColliding OnScriptLandColliding;
         public event ScriptColliding OnScriptLandColliderEnd;
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index 4f2b446..f556b35 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -438,29 +438,31 @@ namespace OpenSim.Region.Framework.Scenes
                 itemCopy.InvType = item.InvType;
                 itemCopy.Folder = recipientFolderId;
 
-                if (Permissions.PropagatePermissions())
+                if (Permissions.PropagatePermissions() && recipient != senderId)
                 {
+                    // First, make sore base is limited to the next perms
+                    itemCopy.BasePermissions = item.BasePermissions & item.NextPermissions;
+                    // By default, current equals base
+                    itemCopy.CurrentPermissions = itemCopy.BasePermissions;
+
+                    // If this is an object, replace current perms
+                    // with folded perms
                     if (item.InvType == (int)InventoryType.Object)
                     {
-                        itemCopy.BasePermissions &= ~(uint)(PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer);
-                        itemCopy.BasePermissions |= (item.CurrentPermissions & 7) << 13;
-                    }
-                    else
-                    {
-                        itemCopy.BasePermissions = item.BasePermissions & item.NextPermissions;
+                        itemCopy.CurrentPermissions &= ~(uint)(PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer);
+                        itemCopy.CurrentPermissions |= (item.CurrentPermissions & 7) << 13;
                     }
 
-                    itemCopy.CurrentPermissions = itemCopy.BasePermissions;
-                    if ((item.CurrentPermissions & 8) != 0) // Propagate slam bit
-                    {
-                        itemCopy.BasePermissions &= item.NextPermissions;
-                        itemCopy.CurrentPermissions = itemCopy.BasePermissions;
-                        itemCopy.CurrentPermissions |= 8;
-                    }
+                    // Ensure there is no escalation
+                    itemCopy.CurrentPermissions &= item.NextPermissions;
+
+                    // Need slam bit on xfer
+                    itemCopy.CurrentPermissions |= 8;
 
                     itemCopy.NextPermissions = item.NextPermissions;
-                    itemCopy.EveryOnePermissions = item.EveryOnePermissions & item.NextPermissions;
-                    itemCopy.GroupPermissions = item.GroupPermissions & item.NextPermissions;
+
+                    itemCopy.EveryOnePermissions = 0;
+                    itemCopy.GroupPermissions = 0;
                 }
                 else
                 {
@@ -531,7 +533,6 @@ namespace OpenSim.Region.Framework.Scenes
                 return null;
             }
 
-
             if (recipientParentFolderId == UUID.Zero)
             {
                 InventoryFolderBase recipientRootFolder = InventoryService.GetRootFolder(recipientId);
@@ -910,12 +911,12 @@ namespace OpenSim.Region.Framework.Scenes
 
             if ((part.OwnerID != destAgent) && Permissions.PropagatePermissions())
             {
+                agentItem.BasePermissions = taskItem.BasePermissions & taskItem.NextPermissions;
                 if (taskItem.InvType == (int)InventoryType.Object)
-                    agentItem.BasePermissions = taskItem.BasePermissions & ((taskItem.CurrentPermissions & 7) << 13);
-                else
-                    agentItem.BasePermissions = taskItem.BasePermissions;
-                agentItem.BasePermissions &= taskItem.NextPermissions;
-                agentItem.CurrentPermissions = agentItem.BasePermissions | 8;
+                    agentItem.CurrentPermissions = agentItem.BasePermissions & ((taskItem.CurrentPermissions & 7) << 13);
+                    agentItem.CurrentPermissions = agentItem.BasePermissions ;
+
+                agentItem.CurrentPermissions |= 8;
                 agentItem.NextPermissions = taskItem.NextPermissions;
                 agentItem.EveryOnePermissions = taskItem.EveryonePermissions & taskItem.NextPermissions;
                 agentItem.GroupPermissions = taskItem.GroupPermissions & taskItem.NextPermissions;
@@ -2075,7 +2076,10 @@ namespace OpenSim.Region.Framework.Scenes
                         group.RootPart.IsAttachment = true;
                     }
 
-                    AddNewSceneObject(group, true);
+                    // If we're rezzing an attachment then don't ask AddNewSceneObject() to update the client since
+                    // we'll be doing that later on.  Scheduling more than one full update during the attachment
+                    // process causes some clients to fail to display the attachment properly.
+                    AddNewSceneObject(group, true, !attachment);
 
                   //  m_log.InfoFormat("ray end point for inventory rezz is {0} {1} {2} ", RayEnd.X, RayEnd.Y, RayEnd.Z);
                     // if attachment we set it's asset id so object updates can reflect that
@@ -2445,6 +2449,8 @@ namespace OpenSim.Region.Framework.Scenes
                 return;
             }
 
+            m_log.DebugFormat("[SCENE INVENTORY]: {0} {1} IsAttachment={2}", att.Name, att.LocalId, att.IsAttachment);
+            Console.WriteLine("HERE X");
             ScenePresence presence;
             if (TryGetAvatar(remoteClient.AgentId, out presence))
             {
@@ -2452,9 +2458,12 @@ namespace OpenSim.Region.Framework.Scenes
                 InventoryItemBase item = new InventoryItemBase(itemID, remoteClient.AgentId);
                 item = InventoryService.GetItem(item);
                 presence.Appearance.SetAttachment((int)AttachmentPt, itemID, item.AssetID /*att.UUID*/);
+                Console.WriteLine("HERE Y");
 
                 if (m_AvatarFactory != null)
                     m_AvatarFactory.UpdateDatabase(remoteClient.AgentId, presence.Appearance);
+
+                Console.WriteLine("HERE Z");
             }
         }
 
@@ -2637,4 +2646,4 @@ namespace OpenSim.Region.Framework.Scenes
             m_sceneGraph.LinkObjects(root, children);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
index ac04dc7..d8e604f 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
@@ -124,6 +124,7 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     if (((SceneObjectGroup)ent).LocalId == primLocalID)
                     {
+                        m_log.DebugFormat("[SCENE]: Received full update request for {0} from {1}", primLocalID, remoteClient.Name);
                         ((SceneObjectGroup)ent).SendFullUpdateToClient(remoteClient);
                         return;
                     }
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 637ebff..f8ca047 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -1850,9 +1850,31 @@ namespace OpenSim.Region.Framework.Scenes
         /// true if the object was added, false if an object with the same uuid was already in the scene
         /// </returns>
         public bool AddRestoredSceneObject(
+            SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted, bool sendClientUpdates)
+        {
+            return m_sceneGraph.AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, sendClientUpdates);
+        }        
+
+        /// <summary>
+        /// Add an object into the scene that has come from storage
+        /// </summary>
+        ///
+        /// <param name="sceneObject"></param>
+        /// <param name="attachToBackup">
+        /// If true, changes to the object will be reflected in its persisted data
+        /// If false, the persisted data will not be changed even if the object in the scene is changed
+        /// </param>
+        /// <param name="alreadyPersisted">
+        /// If true, we won't persist this object until it changes
+        /// If false, we'll persist this object immediately
+        /// </param>
+        /// <returns>
+        /// true if the object was added, false if an object with the same uuid was already in the scene
+        /// </returns>
+        public bool AddRestoredSceneObject(
             SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted)
         {
-            return m_sceneGraph.AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted);
+            return AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, true);
         }
 
         /// <summary>
@@ -1886,7 +1908,7 @@ namespace OpenSim.Region.Framework.Scenes
         }        
 
         /// <summary>
-        /// Delete every object from the scene
+        /// Delete every object from the scene.  This does not include attachments worn by avatars.
         /// </summary>
         public void DeleteAllSceneObjects()
         {
@@ -1897,7 +1919,11 @@ namespace OpenSim.Region.Framework.Scenes
                 foreach (EntityBase e in entities)
                 {
                     if (e is SceneObjectGroup)
-                        DeleteSceneObject((SceneObjectGroup)e, false);
+                    {
+                        SceneObjectGroup sog = (SceneObjectGroup)e;
+                        if (!sog.IsAttachment)
+                            DeleteSceneObject((SceneObjectGroup)e, false);
+                    }
                 }
             }
         }
@@ -2461,7 +2487,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns></returns>
         public bool IncomingCreateObject(ISceneObject sog)
         {
-            //m_log.Debug(" >>> IncomingCreateObject(sog) <<< " + ((SceneObjectGroup)sog).AbsolutePosition + " deleted? " + ((SceneObjectGroup)sog).IsDeleted);
+            m_log.Debug(" >>> IncomingCreateObject(sog) <<< " + ((SceneObjectGroup)sog).AbsolutePosition + " deleted? " + ((SceneObjectGroup)sog).IsDeleted);
             SceneObjectGroup newObject;
             try
             {
@@ -2533,10 +2559,12 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (sceneObject.IsAttachmentCheckFull()) // Attachment
             {
+                m_log.DebugFormat("[SCENE]: Adding attachment {0} {1}", sceneObject.Name, sceneObject.LocalId);
+                
                 sceneObject.RootPart.AddFlag(PrimFlags.TemporaryOnRez);
                 sceneObject.RootPart.AddFlag(PrimFlags.Phantom);
 
-                AddRestoredSceneObject(sceneObject, false, false);
+                AddRestoredSceneObject(sceneObject, false, false, false);
 
                 // Handle attachment special case
                 SceneObjectPart RootPrim = sceneObject.RootPart;
@@ -2544,6 +2572,8 @@ namespace OpenSim.Region.Framework.Scenes
                 // Fix up attachment Parent Local ID
                 ScenePresence sp = GetScenePresence(sceneObject.OwnerID);
 
+                Console.WriteLine("AAAA");
+
                 //uint parentLocalID = 0;
                 if (sp != null)
                 {
@@ -2562,20 +2592,25 @@ namespace OpenSim.Region.Framework.Scenes
                     //grp.SetFromAssetID(grp.RootPart.LastOwnerID);
                     m_log.DebugFormat(
                         "[ATTACHMENT]: Attach to avatar {0} at position {1}", sp.UUID, grp.AbsolutePosition);
-                    
+
+                    RootPrim.RemFlag(PrimFlags.TemporaryOnRez);                    
                     AttachObject(
                         sp.ControllingClient, grp.LocalId, (uint)0, grp.GroupRotation, grp.AbsolutePosition, false);
-                    RootPrim.RemFlag(PrimFlags.TemporaryOnRez);
-                    grp.SendGroupFullUpdate();
+                    
+                    //grp.SendGroupFullUpdate();
                 }
                 else
                 {
                     RootPrim.RemFlag(PrimFlags.TemporaryOnRez);
                     RootPrim.AddFlag(PrimFlags.TemporaryOnRez);
                 }
+
+                Console.WriteLine("BBBB");
             }
             else
             {
+                m_log.DebugFormat("[SCENE]: Adding ordinary object {0} {1}", sceneObject.Name, sceneObject.LocalId);
+                
                 AddRestoredSceneObject(sceneObject, true, false);
 
                 if (!Permissions.CanObjectEntry(sceneObject.UUID,
diff --git a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
index 2f6a0db..50feb17 100644
--- a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
@@ -1383,7 +1383,9 @@ namespace OpenSim.Region.Framework.Scenes
                 // now we have a child agent in this region. Request all interesting data about other (root) agents
                 agent.SendInitialFullUpdateToAllClients();
 
+                Console.WriteLine("SCS 1");
                 agent.CrossAttachmentsIntoNewRegion(neighbourHandle, true);
+                Console.WriteLine("SCS 2");                
 
                 //                    m_scene.SendKillObject(m_localId);
 
diff --git a/OpenSim/Region/Framework/Scenes/SceneGraph.cs b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
index ad24160..fa3c5eb 100644
--- a/OpenSim/Region/Framework/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
@@ -216,11 +216,15 @@ namespace OpenSim.Region.Framework.Scenes
         /// If true, we won't persist this object until it changes
         /// If false, we'll persist this object immediately
         /// </param>
+        /// <param name="sendClientUpdate">
+        /// If true, we send updates to the client to tell it about this object
+        /// If false, we leave it up to the caller to do this
+        /// </param>
         /// <returns>
         /// true if the object was added, false if an object with the same uuid was already in the scene
         /// </returns>
         protected internal bool AddRestoredSceneObject(
-            SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted)
+            SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted, bool sendClientUpdates)
         {
             if (!alreadyPersisted)
             {
@@ -228,8 +232,29 @@ namespace OpenSim.Region.Framework.Scenes
                 sceneObject.HasGroupChanged = true;
             }
 
-            return AddSceneObject(sceneObject, attachToBackup, true);
+            return AddSceneObject(sceneObject, attachToBackup, sendClientUpdates);
         }
+        
+//        /// <summary>
+//        /// Add an object into the scene that has come from storage
+//        /// </summary>
+//        /// <param name="sceneObject"></param>
+//        /// <param name="attachToBackup">
+//        /// If true, changes to the object will be reflected in its persisted data
+//        /// If false, the persisted data will not be changed even if the object in the scene is changed
+//        /// </param>
+//        /// <param name="alreadyPersisted">
+//        /// If true, we won't persist this object until it changes
+//        /// If false, we'll persist this object immediately
+//        /// </param>
+//        /// <returns>
+//        /// true if the object was added, false if an object with the same uuid was already in the scene
+//        /// </returns>
+//        protected internal bool AddRestoredSceneObject(
+//            SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted)
+//        {
+//            AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, true);
+//        }
 
         /// <summary>
         /// Add a newly created object to the scene.  This will both update the scene, and send information about the
@@ -536,7 +561,6 @@ namespace OpenSim.Region.Framework.Scenes
 //                m_log.DebugFormat(
 //                    "[SCENE GRAPH]: Retrieved single object {0} for attachment to {1} on point {2}", 
 //                    objatt.Name, remoteClient.Name, AttachmentPt);
-            
             if (objatt != null)
             {
                 bool tainted = false;
@@ -612,11 +636,13 @@ namespace OpenSim.Region.Framework.Scenes
         protected internal bool AttachObject(
             IClientAPI remoteClient, uint objectLocalID, uint AttachmentPt, Quaternion rot, Vector3 attachPos, bool silent)
         {
+            Console.WriteLine("HERE A");
             SceneObjectGroup group = GetGroupByPrim(objectLocalID);
             if (group != null)
             {
                 if (m_parentScene.Permissions.CanTakeObject(group.UUID, remoteClient.AgentId))
                 {
+                    Console.WriteLine("HERE -1");
                     // If the attachment point isn't the same as the one previously used
                     // set it's offset position = 0 so that it appears on the attachment point
                     // and not in a weird location somewhere unknown.
@@ -655,9 +681,12 @@ namespace OpenSim.Region.Framework.Scenes
                         itemId = group.GetFromItemID();
                     }
 
+                    Console.WriteLine("HERE 0");
                     m_parentScene.AttachObject(remoteClient, AttachmentPt, itemId, group);
 
+                    Console.WriteLine("HERE 1");
                     group.AttachToAgent(remoteClient.AgentId, AttachmentPt, attachPos, silent);
+                    Console.WriteLine("HERE 2");
                     // In case it is later dropped again, don't let
                     // it get cleaned up
                     //
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index c14b39a..ba3fde7 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -1494,6 +1494,10 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SendFullUpdateToClient(IClientAPI remoteClient)
         {
+            if (IsAttachment)
+                m_log.DebugFormat(
+                    "[SOG]: Sending full update to client {0} for {1} {2}", remoteClient.Name, Name, LocalId);
+            
             SendPartFullUpdate(remoteClient, RootPart, m_scene.Permissions.GenerateClientFlags(remoteClient.AgentId, RootPart.UUID));
 
             lock (m_parts)
@@ -1513,8 +1517,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="part"></param>
         internal void SendPartFullUpdate(IClientAPI remoteClient, SceneObjectPart part, uint clientFlags)
         {
-//            m_log.DebugFormat(
-//                "[SOG]: Sendinging part full update to {0} for {1} {2}", remoteClient.Name, part.Name, part.LocalId);
+            if (IsAttachment)
+                m_log.DebugFormat(
+                    "[SOG]: Sending part full update to {0} for {1} {2}", remoteClient.Name, part.Name, part.LocalId);
             
             if (m_rootPart.UUID == part.UUID)
             {
@@ -1994,7 +1999,8 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void ScheduleFullUpdateToAvatar(ScenePresence presence)
         {
-//            m_log.DebugFormat("[SOG]: Scheduling full update for {0} {1} just to avatar {2}", Name, UUID, presence.Name);
+            if (IsAttachment)
+                m_log.DebugFormat("[SOG]: Scheduling full update for {0} {1} just to avatar {2}", Name, UUID, presence.Name);
             
             RootPart.AddFullUpdateToAvatar(presence);
 
@@ -2026,7 +2032,8 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void ScheduleGroupForFullUpdate()
         {
-//            m_log.DebugFormat("[SOG]: Scheduling full update for {0} {1}", Name, UUID);
+            if (IsAttachment)
+                m_log.DebugFormat("[SOG]: Scheduling full update for {0} {1}", Name, UUID);
             
             checkAtTargets();
             RootPart.ScheduleFullUpdate();
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index a85a4b3..ffbb427 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -1259,16 +1259,17 @@ namespace OpenSim.Region.Framework.Scenes
         /// Tell all scene presences that they should send updates for this part to their clients
         /// </summary>
         public void AddFullUpdateToAllAvatars()
-        {
+        {                        
             ScenePresence[] avatars = m_parentGroup.Scene.GetScenePresences();
             for (int i = 0; i < avatars.Length; i++)
-            {
-                avatars[i].SceneViewer.QueuePartForUpdate(this);
-            }
+                AddFullUpdateToAvatar(avatars[i]);
         }
 
         public void AddFullUpdateToAvatar(ScenePresence presence)
         {
+            if (IsAttachment)
+                m_log.DebugFormat("AddFullUpdateToAllAvatar() {0} for {1} {2}", presence.Name, Name, LocalId);
+            
             presence.SceneViewer.QueuePartForUpdate(this);
         }
 
@@ -1287,13 +1288,14 @@ namespace OpenSim.Region.Framework.Scenes
         {
             ScenePresence[] avatars = m_parentGroup.Scene.GetScenePresences();
             for (int i = 0; i < avatars.Length; i++)
-            {
-                avatars[i].SceneViewer.QueuePartForUpdate(this);
-            }
+                AddTerseUpdateToAvatar(avatars[i]);
         }
 
         public void AddTerseUpdateToAvatar(ScenePresence presence)
         {
+            if (IsAttachment)
+                m_log.DebugFormat("AddTerseUpdateToAvatar() {0} for {1} {2}", presence.Name, Name, LocalId);
+            
             presence.SceneViewer.QueuePartForUpdate(this);
         }
 
@@ -2727,7 +2729,8 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void ScheduleFullUpdate()
         {
-//            m_log.DebugFormat("[SCENE OBJECT PART]: Scheduling full update for {0} {1}", Name, LocalId);
+            if (IsAttachment)
+                m_log.DebugFormat("[SOP]: Scheduling full update for {0} {1}", Name, LocalId);
             
             if (m_parentGroup != null)
             {
@@ -2840,6 +2843,10 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="remoteClient"></param>
         public void SendFullUpdate(IClientAPI remoteClient, uint clientFlags)
         {
+            if (IsAttachment)
+                m_log.DebugFormat(
+                    "[SCENE OBJECT PART]: Sending part full update to {0} for {1} {2}", remoteClient.Name, Name, LocalId);
+            
             m_parentGroup.SendPartFullUpdate(remoteClient, this, clientFlags);
         }
 
@@ -2848,6 +2855,10 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void SendFullUpdateToAllClients()
         {
+            if (IsAttachment)
+                m_log.DebugFormat(
+                    "[SCENE OBJECT PART]: Sending full update for {0} {1} for all clients", Name, LocalId);
+            
             ScenePresence[] avatars = m_parentGroup.Scene.GetScenePresences();
             for (int i = 0; i < avatars.Length; i++)
             {
@@ -2859,6 +2870,10 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SendFullUpdateToAllClientsExcept(UUID agentID)
         {
+            if (IsAttachment)
+                m_log.DebugFormat(
+                    "[SCENE OBJECT PART]: Sending full update for {0} {1} to all clients except {2}", Name, LocalId, agentID);
+            
             ScenePresence[] avatars = m_parentGroup.Scene.GetScenePresences();
             for (int i = 0; i < avatars.Length; i++)
             {
@@ -2965,6 +2980,9 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (m_updateFlag == 2) // is a new prim, just created/reloaded or has major changes
                 {
+                    if (IsAttachment)
+                        m_log.DebugFormat("[SOP]: Sending scheduled full update for {0} {1}", Name, LocalId);
+                    
                     AddFullUpdateToAllAvatars();
                     ClearUpdateSchedule();
                 }
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
index a555eae..21ca1de 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
@@ -638,7 +638,6 @@ namespace OpenSim.Region.Framework.Scenes
                     m_items[item.ItemID] = item;
                     m_inventorySerial++;
                     m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
-
                     HasInventoryChanged = true;
                     m_part.ParentGroup.HasGroupChanged = true;
 
diff --git a/OpenSim/Region/Framework/Scenes/SceneViewer.cs b/OpenSim/Region/Framework/Scenes/SceneViewer.cs
index e4296ef..6f2bef9 100644
--- a/OpenSim/Region/Framework/Scenes/SceneViewer.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneViewer.cs
@@ -27,6 +27,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Reflection;
 using OpenMetaverse;
 using log4net;
 using OpenSim.Framework;
@@ -39,6 +40,8 @@ namespace OpenSim.Region.Framework.Scenes
 {
     public class SceneViewer : ISceneViewer
     {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
         protected ScenePresence m_presence;
         protected UpdateQueue m_partsUpdateQueue = new UpdateQueue();
         protected Queue<SceneObjectGroup> m_pendingObjects;
@@ -60,6 +63,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="part"></param>
         public void QueuePartForUpdate(SceneObjectPart part)
         {
+            if (part.IsAttachment)
+                m_log.DebugFormat("[SCENE VIEWER]: Queueing part {0} {1} for update", part.Name, part.LocalId);
+            
             lock (m_partsUpdateQueue)
             {
                 m_partsUpdateQueue.Enqueue(part);
@@ -134,7 +140,7 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                     else if (update.LastTerseUpdateTime <= part.TimeStampTerse)
                     {
-//                            m_log.DebugFormat(
+//                            m_log.DebugFormat(AddFullUpdateToAvatar
 //                                "[SCENE PRESENCE]: Tersely updating prim {0}, {1} - part timestamp {2}",
 //                                part.Name, part.UUID, part.TimeStampTerse);
 
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs
index 00fe5df..06aad91 100644
--- a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs
@@ -28,41 +28,30 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-
-
 using log4net;
 using Mono.Addins;
 using Nini.Config;
-
 using OpenMetaverse;
 using OpenMetaverse.StructuredData;
-
 using OpenSim.Framework;
 using OpenSim.Region.CoreModules.Framework.EventQueue;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 
-
 using Caps = OpenSim.Framework.Capabilities.Caps;
 
 namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 {
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
-    public class GroupsMessagingModule : ISharedRegionModule
+    public class GroupsMessagingModule : ISharedRegionModule, IGroupsMessagingModule
     {
-
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private List<Scene> m_sceneList = new List<Scene>();
 
         private IMessageTransferModule m_msgTransferModule = null;
 
-        private IGroupsModule m_groupsModule = null;
-
-        // TODO: Move this off to the Groups Server
-        public Dictionary<Guid, List<Guid>> m_agentsInGroupSession = new Dictionary<Guid, List<Guid>>();
-        public Dictionary<Guid, List<Guid>> m_agentsDroppedSession = new Dictionary<Guid, List<Guid>>();
-
+        private IGroupsServicesConnector m_groupData = null;
 
         // Config Options
         private bool m_groupMessagingEnabled = false;
@@ -108,8 +97,12 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         public void AddRegion(Scene scene)
         {
-            // NoOp
+            if (!m_groupMessagingEnabled)
+                return;
+            
+            scene.RegisterModuleInterface<IGroupsMessagingModule>(this);
         }
+        
         public void RegionLoaded(Scene scene)
         {
             if (!m_groupMessagingEnabled)
@@ -117,12 +110,12 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            m_groupsModule = scene.RequestModuleInterface<IGroupsModule>();
+            m_groupData = scene.RequestModuleInterface<IGroupsServicesConnector>();
 
             // No groups module, no groups messaging
-            if (m_groupsModule == null)
+            if (m_groupData == null)
             {
-                m_log.Error("[GROUPS-MESSAGING]: Could not get IGroupsModule, GroupsMessagingModule is now disabled.");
+                m_log.Error("[GROUPS-MESSAGING]: Could not get IGroupsServicesConnector, GroupsMessagingModule is now disabled.");
                 Close();
                 m_groupMessagingEnabled = false;
                 return;
@@ -144,7 +137,6 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             scene.EventManager.OnNewClient += OnNewClient;
             scene.EventManager.OnIncomingInstantMessage += OnGridInstantMessage;
-
         }
 
         public void RemoveRegion(Scene scene)
@@ -172,7 +164,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             m_sceneList.Clear();
 
-            m_groupsModule = null;
+            m_groupData = null;
             m_msgTransferModule = null;
         }
 
@@ -197,6 +189,75 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         #endregion
 
+        /// <summary>
+        /// Not really needed, but does confirm that the group exists.
+        /// </summary>
+        public bool StartGroupChatSession(UUID agentID, UUID groupID)
+        {
+            if (m_debugEnabled)
+                m_log.DebugFormat("[GROUPS-MESSAGING]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+                
+            GroupRecord groupInfo = m_groupData.GetGroupRecord(agentID, groupID, null);
+
+            if (groupInfo != null)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        
+        public void SendMessageToGroup(GridInstantMessage im, UUID groupID)
+        {
+            if (m_debugEnabled) 
+                m_log.DebugFormat("[GROUPS-MESSAGING]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+
+            foreach (GroupMembersData member in m_groupData.GetGroupMembers(UUID.Zero, groupID))
+            {
+                if (m_groupData.hasAgentDroppedGroupChatSession(member.AgentID, groupID))
+                {
+                    // Don't deliver messages to people who have dropped this session
+                    if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: {0} has dropped session, not delivering to them", member.AgentID);
+                    continue;
+                }
+
+                // Copy Message
+                GridInstantMessage msg = new GridInstantMessage();
+                msg.imSessionID = groupID.Guid;
+                msg.fromAgentName = im.fromAgentName;
+                msg.message = im.message;
+                msg.dialog = im.dialog;
+                msg.offline = im.offline;
+                msg.ParentEstateID = im.ParentEstateID;
+                msg.Position = im.Position;
+                msg.RegionID = im.RegionID;
+                msg.binaryBucket = im.binaryBucket;
+                msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
+
+                msg.fromAgentID = im.fromAgentID;
+                msg.fromGroup = true;
+
+                msg.toAgentID = member.AgentID.Guid;
+
+                IClientAPI client = GetActiveClient(member.AgentID);
+                if (client == null)
+                {
+                    // If they're not local, forward across the grid
+                    if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: Delivering to {0} via Grid", member.AgentID);
+                    m_msgTransferModule.SendInstantMessage(msg, delegate(bool success) { });
+                }
+                else
+                {
+                    // Deliver locally, directly
+                    if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: Passing to ProcessMessageFromGroupSession to deliver to {0} locally", client.Name);
+                    ProcessMessageFromGroupSession(msg);
+                }
+            }
+        }
+        
         #region SimGridEventHandlers
 
         private void OnNewClient(IClientAPI client)
@@ -236,42 +297,46 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: Session message from {0} going to agent {1}", msg.fromAgentName, msg.toAgentID);
 
+            UUID AgentID = new UUID(msg.fromAgentID);
+            UUID GroupID = new UUID(msg.imSessionID);
+
             switch (msg.dialog)
             {
                 case (byte)InstantMessageDialog.SessionAdd:
-                    AddAgentToGroupSession(msg.fromAgentID, msg.imSessionID);
+                    m_groupData.AgentInvitedToGroupChatSession(AgentID, GroupID);
                     break;
 
                 case (byte)InstantMessageDialog.SessionDrop:
-                    RemoveAgentFromGroupSession(msg.fromAgentID, msg.imSessionID);
+                    m_groupData.AgentDroppedFromGroupChatSession(AgentID, GroupID);
                     break;
 
                 case (byte)InstantMessageDialog.SessionSend:
-                    if (!m_agentsInGroupSession.ContainsKey(msg.toAgentID)
-                        && !m_agentsDroppedSession.ContainsKey(msg.toAgentID))
+                    if (!m_groupData.hasAgentDroppedGroupChatSession(AgentID, GroupID)
+                        && !m_groupData.hasAgentBeenInvitedToGroupChatSession(AgentID, GroupID)
+                        )
                     {
                         // Agent not in session and hasn't dropped from session
                         // Add them to the session for now, and Invite them
-                        AddAgentToGroupSession(msg.toAgentID, msg.imSessionID);
+                        m_groupData.AgentInvitedToGroupChatSession(AgentID, GroupID);
 
                         UUID toAgentID = new UUID(msg.toAgentID);
                         IClientAPI activeClient = GetActiveClient(toAgentID);
                         if (activeClient != null)
                         {
-                            UUID groupID = new UUID(msg.fromAgentID);
-
-                            GroupRecord groupInfo = m_groupsModule.GetGroupRecord(groupID);
+                            GroupRecord groupInfo = m_groupData.GetGroupRecord(UUID.Zero, GroupID, null);
                             if (groupInfo != null)
                             {
                                 if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: Sending chatterbox invite instant message");
 
                                 // Force? open the group session dialog???
+                                // and simultanously deliver the message, so we don't need to do a seperate client.SendInstantMessage(msg);
                                 IEventQueue eq = activeClient.Scene.RequestModuleInterface<IEventQueue>();
                                 eq.ChatterboxInvitation(
-                                    groupID
+                                    GroupID
                                     , groupInfo.GroupName
                                     , new UUID(msg.fromAgentID)
-                                    , msg.message, new UUID(msg.toAgentID)
+                                    , msg.message
+                                    , new UUID(msg.toAgentID)
                                     , msg.fromAgentName
                                     , msg.dialog
                                     , msg.timestamp
@@ -285,7 +350,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                                     );
 
                                 eq.ChatterBoxSessionAgentListUpdates(
-                                    new UUID(groupID)
+                                    new UUID(GroupID)
                                     , new UUID(msg.fromAgentID)
                                     , new UUID(msg.toAgentID)
                                     , false //canVoiceChat
@@ -295,7 +360,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                             }
                         }
                     }
-                    else if (!m_agentsDroppedSession.ContainsKey(msg.toAgentID))
+                    else if (!m_groupData.hasAgentDroppedGroupChatSession(AgentID, GroupID))
                     {
                         // User hasn't dropped, so they're in the session, 
                         // maybe we should deliver it.
@@ -321,56 +386,8 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         #endregion
 
-        #region ClientEvents
-
-        private void RemoveAgentFromGroupSession(Guid agentID, Guid sessionID)
-        {
-            if (m_agentsInGroupSession.ContainsKey(sessionID))
-            {
-                // If in session remove
-                if (m_agentsInGroupSession[sessionID].Contains(agentID))
-                {
-                    m_agentsInGroupSession[sessionID].Remove(agentID);
-                }
-
-                // If not in dropped list, add
-                if (!m_agentsDroppedSession[sessionID].Contains(agentID))
-                {
-                    if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: Dropped {1} from session {0}", sessionID, agentID);
-                    m_agentsDroppedSession[sessionID].Add(agentID);
-                }
-            }
-        }
-
-        private void AddAgentToGroupSession(Guid agentID, Guid sessionID)
-        {
-            // Add Session Status if it doesn't exist for this session
-            CreateGroupSessionTracking(sessionID);
-
-            // If nessesary, remove from dropped list
-            if (m_agentsDroppedSession[sessionID].Contains(agentID))
-            {
-                m_agentsDroppedSession[sessionID].Remove(agentID);
-            }
-
-            // If nessesary, add to in session list
-            if (!m_agentsInGroupSession[sessionID].Contains(agentID))
-            {
-                if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: Added {1} to session {0}", sessionID, agentID);
-                m_agentsInGroupSession[sessionID].Add(agentID);
-            }
-        }
-
-        private void CreateGroupSessionTracking(Guid sessionID)
-        {
-            if (!m_agentsInGroupSession.ContainsKey(sessionID))
-            {
-                if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: Creating session tracking for : {0}", sessionID);
-                m_agentsInGroupSession.Add(sessionID, new List<Guid>());
-                m_agentsDroppedSession.Add(sessionID, new List<Guid>());
-            }
-        }
 
+        #region ClientEvents
         private void OnInstantMessage(IClientAPI remoteClient, GridInstantMessage im)
         {
             if (m_debugEnabled)
@@ -383,21 +400,23 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             // Start group IM session
             if ((im.dialog == (byte)InstantMessageDialog.SessionGroupStart))
             {
-                UUID groupID = new UUID(im.toAgentID);
+                if (m_debugEnabled) m_log.InfoFormat("[GROUPS-MESSAGING]: imSessionID({0}) toAgentID({1})", im.imSessionID, im.toAgentID);
 
-                GroupRecord groupInfo = m_groupsModule.GetGroupRecord(groupID);
+                UUID GroupID = new UUID(im.imSessionID);
+                UUID AgentID = new UUID(im.fromAgentID);
+
+                GroupRecord groupInfo = m_groupData.GetGroupRecord(UUID.Zero, GroupID, null);
+    
                 if (groupInfo != null)
                 {
-                    if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: Start Group Session for {0}", groupInfo.GroupName);
-
-                    AddAgentToGroupSession(im.fromAgentID, im.imSessionID);
+                    m_groupData.AgentInvitedToGroupChatSession(AgentID, GroupID);
 
-                    ChatterBoxSessionStartReplyViaCaps(remoteClient, groupInfo.GroupName, groupID);
+                    ChatterBoxSessionStartReplyViaCaps(remoteClient, groupInfo.GroupName, GroupID);
 
                     IEventQueue queue = remoteClient.Scene.RequestModuleInterface<IEventQueue>();
                     queue.ChatterBoxSessionAgentListUpdates(
-                        new UUID(groupID)
-                        , new UUID(im.fromAgentID)
+                        GroupID
+                        , AgentID
                         , new UUID(im.toAgentID)
                         , false //canVoiceChat
                         , false //isModerator
@@ -409,64 +428,21 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             // Send a message from locally connected client to a group
             if ((im.dialog == (byte)InstantMessageDialog.SessionSend))
             {
-                UUID groupID = new UUID(im.toAgentID);
+                UUID GroupID = new UUID(im.imSessionID);
+                UUID AgentID = new UUID(im.fromAgentID);
 
-                if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: Send message to session for group {0} with session ID {1}", groupID, im.imSessionID.ToString());
+                if (m_debugEnabled) 
+                    m_log.DebugFormat("[GROUPS-MESSAGING]: Send message to session for group {0} with session ID {1}", GroupID, im.imSessionID.ToString());
 
-                SendMessageToGroup(im, groupID);
+                //If this agent is sending a message, then they want to be in the session
+                m_groupData.AgentInvitedToGroupChatSession(AgentID, GroupID);
+
+                SendMessageToGroup(im, GroupID);
             }
         }
 
         #endregion
 
-        private void SendMessageToGroup(GridInstantMessage im, UUID groupID)
-        {
-            if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
-
-            foreach (GroupMembersData member in m_groupsModule.GroupMembersRequest(null, groupID))
-            {
-                if (!m_agentsDroppedSession.ContainsKey(im.imSessionID) || m_agentsDroppedSession[im.imSessionID].Contains(member.AgentID.Guid))
-                {
-                    // Don't deliver messages to people who have dropped this session
-                    if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: {0} has dropped session, not delivering to them", member.AgentID);
-                    continue;
-                }
-
-                // Copy Message
-                GridInstantMessage msg = new GridInstantMessage();
-                msg.imSessionID = im.imSessionID;
-                msg.fromAgentName = im.fromAgentName;
-                msg.message = im.message;
-                msg.dialog = im.dialog;
-                msg.offline = im.offline;
-                msg.ParentEstateID = im.ParentEstateID;
-                msg.Position = im.Position;
-                msg.RegionID = im.RegionID;
-                msg.binaryBucket = im.binaryBucket;
-                msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
-
-                // Updat Pertinate fields to make it a "group message"
-                msg.fromAgentID = groupID.Guid;
-                msg.fromGroup = true;
-
-                msg.toAgentID = member.AgentID.Guid;
-
-                IClientAPI client = GetActiveClient(member.AgentID);
-                if (client == null)
-                {
-                    // If they're not local, forward across the grid
-                    if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: Delivering to {0} via Grid", member.AgentID);
-                    m_msgTransferModule.SendInstantMessage(msg, delegate(bool success) { });
-                }
-                else
-                {
-                    // Deliver locally, directly
-                    if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: Passing to ProcessMessageFromGroupSession to deliver to {0} locally", client.Name);
-                    ProcessMessageFromGroupSession(msg);
-                }
-            }
-        }
-
         void ChatterBoxSessionStartReplyViaCaps(IClientAPI remoteClient, string groupName, UUID groupID)
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
@@ -518,6 +494,8 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         /// </summary>
         private IClientAPI GetActiveClient(UUID agentID)
         {
+            if (m_debugEnabled) m_log.WarnFormat("[GROUPS-MESSAGING]: Looking for local client {0}", agentID);
+
             IClientAPI child = null;
 
             // Try root avatar first
@@ -529,16 +507,26 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                     ScenePresence user = (ScenePresence)scene.Entities[agentID];
                     if (!user.IsChildAgent)
                     {
+                        if (m_debugEnabled) m_log.WarnFormat("[GROUPS-MESSAGING]: Found root agent for client : {0}", user.ControllingClient.Name);
                         return user.ControllingClient;
                     }
                     else
                     {
+                        if (m_debugEnabled) m_log.WarnFormat("[GROUPS-MESSAGING]: Found child agent for client : {0}", user.ControllingClient.Name);
                         child = user.ControllingClient;
                     }
                 }
             }
 
             // If we didn't find a root, then just return whichever child we found, or null if none
+            if (child == null)
+            {
+                if (m_debugEnabled) m_log.WarnFormat("[GROUPS-MESSAGING]: Could not find local client for agent : {0}", agentID);
+            }
+            else
+            {
+                if (m_debugEnabled) m_log.WarnFormat("[GROUPS-MESSAGING]: Returning child agent for client : {0}", child.Name);
+            }
             return child;
         }
 
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs
index 8d32e66..3e05732 100644
--- a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs
@@ -87,16 +87,6 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         
         private IGroupsServicesConnector m_groupData = null;
 
-        class GroupRequestIDInfo
-        {
-            public GroupRequestID RequestID = new GroupRequestID();
-            public DateTime LastUsedTMStamp = DateTime.MinValue;
-        }
-        private Dictionary<UUID, GroupRequestIDInfo> m_clientRequestIDInfo = new Dictionary<UUID, GroupRequestIDInfo>();
-        private const int m_clientRequestIDFlushTimeOut = 300000; // Every 5 minutes
-        private Timer m_clientRequestIDFlushTimer;
-
-
         // Configuration settings
         private bool m_groupsEnabled = false;
         private bool m_groupNoticesEnabled = true;
@@ -133,30 +123,6 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                 m_groupNoticesEnabled   = groupsConfig.GetBoolean("NoticesEnabled", true);
                 m_debugEnabled          = groupsConfig.GetBoolean("DebugEnabled", true);
 
-                m_clientRequestIDFlushTimer = new Timer();
-                m_clientRequestIDFlushTimer.Interval = m_clientRequestIDFlushTimeOut;
-                m_clientRequestIDFlushTimer.Elapsed += FlushClientRequestIDInfoCache;
-                m_clientRequestIDFlushTimer.AutoReset = true;
-                m_clientRequestIDFlushTimer.Start();
-            }
-        }
-
-        void FlushClientRequestIDInfoCache(object sender, ElapsedEventArgs e)
-        {
-            lock (m_clientRequestIDInfo)
-            {
-                TimeSpan cacheTimeout = new TimeSpan(0,0, m_clientRequestIDFlushTimeOut / 1000);
-                UUID[] CurrentKeys = new UUID[m_clientRequestIDInfo.Count];
-                foreach (UUID key in CurrentKeys)
-                {
-                    if (m_clientRequestIDInfo.ContainsKey(key))
-                    {
-                        if (DateTime.Now - m_clientRequestIDInfo[key].LastUsedTMStamp > cacheTimeout)
-                        {
-                            m_clientRequestIDInfo.Remove(key);
-                        }
-                    }
-                }
             }
         }
 
@@ -234,8 +200,6 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                 return;
 
             if (m_debugEnabled) m_log.Debug("[GROUPS]: Shutting down Groups module.");
-
-            m_clientRequestIDFlushTimer.Stop();
         }
 
         public Type ReplaceableInterface 
@@ -272,14 +236,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             // Used for Notices and Group Invites/Accept/Reject
             client.OnInstantMessage += OnInstantMessage;
 
-            lock (m_clientRequestIDInfo)
-            {
-                if (m_clientRequestIDInfo.ContainsKey(client.AgentId))
-                {
-                    // flush any old RequestID information
-                    m_clientRequestIDInfo.Remove(client.AgentId);
-                }
-            }
+            // Send client thier groups information.
             SendAgentGroupDataUpdate(client, client.AgentId);
         }
 
@@ -287,7 +244,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            //GroupMembershipData[] avatarGroups = m_groupData.GetAgentGroupMemberships(GetClientGroupRequestID(remoteClient), avatarID).ToArray();
+            //GroupMembershipData[] avatarGroups = m_groupData.GetAgentGroupMemberships(GetRequestingAgentID(remoteClient), avatarID).ToArray();
             GroupMembershipData[] avatarGroups = GetProfileListedGroupMemberships(remoteClient, avatarID);
             remoteClient.SendAvatarGroupsReply(avatarID, avatarGroups);
         }
@@ -331,10 +288,13 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         {
             if (((DirFindFlags)queryFlags & DirFindFlags.Groups) == DirFindFlags.Groups)
             {
-                if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called with queryText({1}) queryFlags({2}) queryStart({3})", System.Reflection.MethodBase.GetCurrentMethod().Name, queryText, (DirFindFlags)queryFlags, queryStart);
+                if (m_debugEnabled) 
+                    m_log.DebugFormat(
+                        "[GROUPS]: {0} called with queryText({1}) queryFlags({2}) queryStart({3})", 
+                        System.Reflection.MethodBase.GetCurrentMethod().Name, queryText, (DirFindFlags)queryFlags, queryStart);
 
                 // TODO: This currently ignores pretty much all the query flags including Mature and sort order
-                remoteClient.SendDirGroupsReply(queryID, m_groupData.FindGroups(GetClientGroupRequestID(remoteClient), queryText).ToArray());
+                remoteClient.SendDirGroupsReply(queryID, m_groupData.FindGroups(GetRequestingAgentID(remoteClient), queryText).ToArray());
             }
             
         }
@@ -348,7 +308,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             string activeGroupName = string.Empty;
             ulong activeGroupPowers  = (ulong)GroupPowers.None;
 
-            GroupMembershipData membership = m_groupData.GetAgentActiveMembership(GetClientGroupRequestID(remoteClient), dataForAgentID);
+            GroupMembershipData membership = m_groupData.GetAgentActiveMembership(GetRequestingAgentID(remoteClient), dataForAgentID);
             if (membership != null)
             {
                 activeGroupID = membership.GroupID;
@@ -361,13 +321,13 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             SendScenePresenceUpdate(dataForAgentID, activeGroupTitle);
         }
 
-        private void HandleUUIDGroupNameRequest(UUID GroupID,IClientAPI remoteClient)
+        private void HandleUUIDGroupNameRequest(UUID GroupID, IClientAPI remoteClient)
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
             string GroupName;
             
-            GroupRecord group = m_groupData.GetGroupRecord(GetClientGroupRequestID(remoteClient), GroupID, null);
+            GroupRecord group = m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), GroupID, null);
             if (group != null)
             {
                 GroupName = group.GroupName;
@@ -382,13 +342,19 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         private void OnInstantMessage(IClientAPI remoteClient, GridInstantMessage im)
         {
-            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+            if (m_debugEnabled)
+            {
+                m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+                m_log.DebugFormat("[GROUPS]: remoteClient ({0}) im ({1})", remoteClient, im);
+
+            }
+
 
             // Group invitations
             if ((im.dialog == (byte)InstantMessageDialog.GroupInvitationAccept) || (im.dialog == (byte)InstantMessageDialog.GroupInvitationDecline))
             {
                 UUID inviteID = new UUID(im.imSessionID);
-                GroupInviteInfo inviteInfo = m_groupData.GetAgentToGroupInvite(GetClientGroupRequestID(remoteClient), inviteID);
+                GroupInviteInfo inviteInfo = m_groupData.GetAgentToGroupInvite(GetRequestingAgentID(remoteClient), inviteID);
 
                 if (inviteInfo == null)
                 {
@@ -407,7 +373,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                         if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: Received an accept invite notice.");
 
                         // and the sessionid is the role
-                        m_groupData.AddAgentToGroup(GetClientGroupRequestID(remoteClient), inviteInfo.AgentID, inviteInfo.GroupID, inviteInfo.RoleID);
+                        m_groupData.AddAgentToGroup(GetRequestingAgentID(remoteClient), inviteInfo.AgentID, inviteInfo.GroupID, inviteInfo.RoleID);
 
                         GridInstantMessage msg = new GridInstantMessage();
                         msg.imSessionID = UUID.Zero.Guid;
@@ -431,14 +397,14 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                         // TODO: If the inviter is still online, they need an agent dataupdate 
                         // and maybe group membership updates for the invitee
 
-                        m_groupData.RemoveAgentToGroupInvite(GetClientGroupRequestID(remoteClient), inviteID);
+                        m_groupData.RemoveAgentToGroupInvite(GetRequestingAgentID(remoteClient), inviteID);
                     }
 
                     // Reject
                     if (im.dialog == (byte)InstantMessageDialog.GroupInvitationDecline)
                     {
                         if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: Received a reject invite notice.");
-                        m_groupData.RemoveAgentToGroupInvite(GetClientGroupRequestID(remoteClient), inviteID);
+                        m_groupData.RemoveAgentToGroupInvite(GetRequestingAgentID(remoteClient), inviteID);
                     }
                 }
             }
@@ -452,7 +418,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                 }
 
                 UUID GroupID = new UUID(im.toAgentID);
-                if (m_groupData.GetGroupRecord(GetClientGroupRequestID(remoteClient), GroupID, null) != null)
+                if (m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), GroupID, null) != null)
                 {
                     UUID NoticeID = UUID.Random();
                     string Subject = im.message.Substring(0, im.message.IndexOf('|'));
@@ -496,14 +462,14 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                     }
 
                     
-                    m_groupData.AddGroupNotice(GetClientGroupRequestID(remoteClient), GroupID, NoticeID, im.fromAgentName, Subject, Message, bucket);
+                    m_groupData.AddGroupNotice(GetRequestingAgentID(remoteClient), GroupID, NoticeID, im.fromAgentName, Subject, Message, bucket);
                     if (OnNewGroupNotice != null)
                     {
                         OnNewGroupNotice(GroupID, NoticeID);
                     }
 
                     // Send notice out to everyone that wants notices
-                    foreach (GroupMembersData member in m_groupData.GetGroupMembers(GetClientGroupRequestID(remoteClient), GroupID))
+                    foreach (GroupMembersData member in m_groupData.GetGroupMembers(GetRequestingAgentID(remoteClient), GroupID))
                     {
                          if (m_debugEnabled)
                         {
@@ -521,7 +487,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                        if (member.AcceptNotices)
                         {
                             // Build notice IIM
-                            GridInstantMessage msg = CreateGroupNoticeIM(UUID.Zero, NoticeID, (byte)OpenMetaverse.InstantMessageDialog.GroupNotice);
+                            GridInstantMessage msg = CreateGroupNoticeIM(GetRequestingAgentID(remoteClient), NoticeID, (byte)OpenMetaverse.InstantMessageDialog.GroupNotice);
 
                             msg.toAgentID = member.AgentID.Guid;
                             OutgoingInstantMessage(msg, member.AgentID);
@@ -549,7 +515,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                 IClientAPI ejectee = GetActiveClient(ejecteeID);
                 if (ejectee != null)
                 {
-                    UUID groupID = new UUID(im.fromAgentID);
+                    UUID groupID = new UUID(im.imSessionID);
                     ejectee.SendAgentDropGroup(groupID);
                 }
             }
@@ -588,20 +554,25 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         public GroupRecord GetGroupRecord(UUID GroupID)
         {
-            return m_groupData.GetGroupRecord(null, GroupID, null);
+            return m_groupData.GetGroupRecord(UUID.Zero, GroupID, null);
         }
 
+        public GroupRecord GetGroupRecord(string name)
+        {
+            return m_groupData.GetGroupRecord(UUID.Zero, UUID.Zero, name);
+        }
+        
         public void ActivateGroup(IClientAPI remoteClient, UUID groupID)
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            m_groupData.SetAgentActiveGroup(GetClientGroupRequestID(remoteClient), remoteClient.AgentId, groupID);
+            m_groupData.SetAgentActiveGroup(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);
 
             // Changing active group changes title, active powers, all kinds of things
             // anyone who is in any region that can see this client, should probably be 
             // updated with new group info.  At a minimum, they should get ScenePresence
             // updated with new title.
-            UpdateAllClientsWithGroupInfo(remoteClient.AgentId);
+            UpdateAllClientsWithGroupInfo(GetRequestingAgentID(remoteClient));
         }
 
         /// <summary>
@@ -611,10 +582,9 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            GroupRequestID grID = GetClientGroupRequestID(remoteClient);
 
-            List<GroupRolesData> agentRoles = m_groupData.GetAgentGroupRoles(grID, remoteClient.AgentId, groupID);
-            GroupMembershipData agentMembership = m_groupData.GetAgentGroupMembership(grID, remoteClient.AgentId, groupID);
+            List<GroupRolesData> agentRoles = m_groupData.GetAgentGroupRoles(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);
+            GroupMembershipData agentMembership = m_groupData.GetAgentGroupMembership(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);
 
             List<GroupTitlesData> titles = new List<GroupTitlesData>();
             foreach (GroupRolesData role in agentRoles)
@@ -636,8 +606,15 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         public List<GroupMembersData> GroupMembersRequest(IClientAPI remoteClient, UUID groupID)
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+            List<GroupMembersData> data = m_groupData.GetGroupMembers(GetRequestingAgentID(remoteClient), groupID);
 
-            List<GroupMembersData> data = m_groupData.GetGroupMembers(GetClientGroupRequestID(remoteClient), groupID);
+            if (m_debugEnabled)
+            {
+                foreach (GroupMembersData member in data)
+                {
+                    m_log.DebugFormat("[GROUPS]: Member({0}) - IsOwner({1})", member.AgentID, member.IsOwner);
+                }
+            }
 
             return data;
 
@@ -647,21 +624,25 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            List<GroupRolesData> data = m_groupData.GetGroupRoles(GetClientGroupRequestID(remoteClient), groupID);
+            List<GroupRolesData> data = m_groupData.GetGroupRoles(GetRequestingAgentID(remoteClient), groupID);
 
             return data;
-
         }
 
         public List<GroupRoleMembersData> GroupRoleMembersRequest(IClientAPI remoteClient, UUID groupID)
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            List<GroupRoleMembersData> data = m_groupData.GetGroupRoleMembers(GetClientGroupRequestID(remoteClient), groupID);
+            List<GroupRoleMembersData> data = m_groupData.GetGroupRoleMembers(GetRequestingAgentID(remoteClient), groupID);
 
+            if (m_debugEnabled)
+            {
+                foreach (GroupRoleMembersData member in data)
+                {
+                    m_log.DebugFormat("[GROUPS]: Member({0}) - Role({1})", member.MemberID, member.RoleID);
+                }
+            }
             return data;
-
-
         }
 
         public GroupProfileData GroupProfileRequest(IClientAPI remoteClient, UUID groupID)
@@ -670,17 +651,16 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             GroupProfileData profile = new GroupProfileData();
 
-            GroupRequestID grID = GetClientGroupRequestID(remoteClient);
 
-            GroupRecord groupInfo = m_groupData.GetGroupRecord(GetClientGroupRequestID(remoteClient), groupID, null);
+            GroupRecord groupInfo = m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), groupID, null);
             if (groupInfo != null)
             {
                 profile.AllowPublish = groupInfo.AllowPublish;
                 profile.Charter = groupInfo.Charter;
                 profile.FounderID = groupInfo.FounderID;
                 profile.GroupID = groupID;
-                profile.GroupMembershipCount = m_groupData.GetGroupMembers(grID, groupID).Count;
-                profile.GroupRolesCount = m_groupData.GetGroupRoles(grID, groupID).Count;
+                profile.GroupMembershipCount = m_groupData.GetGroupMembers(GetRequestingAgentID(remoteClient), groupID).Count;
+                profile.GroupRolesCount = m_groupData.GetGroupRoles(GetRequestingAgentID(remoteClient), groupID).Count;
                 profile.InsigniaID = groupInfo.GroupPicture;
                 profile.MaturePublish = groupInfo.MaturePublish;
                 profile.MembershipFee = groupInfo.MembershipFee;
@@ -691,7 +671,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                 profile.ShowInList = groupInfo.ShowInList;
             }
 
-            GroupMembershipData memberInfo = m_groupData.GetAgentGroupMembership(grID, remoteClient.AgentId, groupID);
+            GroupMembershipData memberInfo = m_groupData.GetAgentGroupMembership(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);
             if (memberInfo != null)
             {
                 profile.MemberTitle = memberInfo.GroupTitle;
@@ -705,40 +685,40 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            return m_groupData.GetAgentGroupMemberships(null, agentID).ToArray();
+            return m_groupData.GetAgentGroupMemberships(UUID.Zero, agentID).ToArray();
         }
 
         public GroupMembershipData GetMembershipData(UUID groupID, UUID agentID)
         {
-            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+            if (m_debugEnabled) 
+                m_log.DebugFormat(
+                    "[GROUPS]: {0} called with groupID={1}, agentID={2}",
+                    System.Reflection.MethodBase.GetCurrentMethod().Name, groupID, agentID);
 
-            return m_groupData.GetAgentGroupMembership(null, agentID, groupID);
+            return m_groupData.GetAgentGroupMembership(UUID.Zero, agentID, groupID);
         }
 
         public void UpdateGroupInfo(IClientAPI remoteClient, UUID groupID, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish)
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            // TODO: Security Check?
-
-            m_groupData.UpdateGroup(GetClientGroupRequestID(remoteClient), groupID, charter, showInList, insigniaID, membershipFee, openEnrollment, allowPublish, maturePublish);
+            // Note: Permissions checking for modification rights is handled by the Groups Server/Service
+            m_groupData.UpdateGroup(GetRequestingAgentID(remoteClient), groupID, charter, showInList, insigniaID, membershipFee, openEnrollment, allowPublish, maturePublish);
         }
 
         public void SetGroupAcceptNotices(IClientAPI remoteClient, UUID groupID, bool acceptNotices, bool listInProfile)
         {
-            // TODO: Security Check?
+            // Note: Permissions checking for modification rights is handled by the Groups Server/Service
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            m_groupData.SetAgentGroupInfo(GetClientGroupRequestID(remoteClient), remoteClient.AgentId, groupID, acceptNotices, listInProfile);
+            m_groupData.SetAgentGroupInfo(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID, acceptNotices, listInProfile);
         }
 
         public UUID CreateGroup(IClientAPI remoteClient, string name, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish)
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            GroupRequestID grID = GetClientGroupRequestID(remoteClient);
-
-            if (m_groupData.GetGroupRecord(grID, UUID.Zero, name) != null)
+            if (m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), UUID.Zero, name) != null)
             {
                 remoteClient.SendCreateGroupReply(UUID.Zero, false, "A group with the same name already exists.");
                 return UUID.Zero;
@@ -754,12 +734,12 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                 }
                 money.ApplyGroupCreationCharge(remoteClient.AgentId);
             }
-            UUID groupID = m_groupData.CreateGroup(grID, name, charter, showInList, insigniaID, membershipFee, openEnrollment, allowPublish, maturePublish, remoteClient.AgentId);
+            UUID groupID = m_groupData.CreateGroup(GetRequestingAgentID(remoteClient), name, charter, showInList, insigniaID, membershipFee, openEnrollment, allowPublish, maturePublish, GetRequestingAgentID(remoteClient));
 
             remoteClient.SendCreateGroupReply(groupID, true, "Group created successfullly");
 
             // Update the founder with new group information.
-            SendAgentGroupDataUpdate(remoteClient, remoteClient.AgentId);
+            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
 
             return groupID;
         }
@@ -770,7 +750,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             // ToDo: check if agent is a member of group and is allowed to see notices?
 
-            return m_groupData.GetGroupNotices(GetClientGroupRequestID(remoteClient), groupID).ToArray();
+            return m_groupData.GetGroupNotices(GetRequestingAgentID(remoteClient), groupID).ToArray();
         }
 
         /// <summary>
@@ -780,7 +760,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            GroupMembershipData membership = m_groupData.GetAgentActiveMembership(null, avatarID);
+            GroupMembershipData membership = m_groupData.GetAgentActiveMembership(UUID.Zero, avatarID);
             if (membership != null)
             {
                 return membership.GroupTitle;
@@ -795,13 +775,13 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            m_groupData.SetAgentActiveGroupRole(GetClientGroupRequestID(remoteClient), remoteClient.AgentId, groupID, titleRoleID);
+            m_groupData.SetAgentActiveGroupRole(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID, titleRoleID);
 
             // TODO: Not sure what all is needed here, but if the active group role change is for the group
             // the client currently has set active, then we need to do a scene presence update too
-            // if (m_groupData.GetAgentActiveMembership(remoteClient.AgentId).GroupID == GroupID)
+            // if (m_groupData.GetAgentActiveMembership(GetRequestingAgentID(remoteClient)).GroupID == GroupID)
                 
-            UpdateAllClientsWithGroupInfo(remoteClient.AgentId);
+            UpdateAllClientsWithGroupInfo(GetRequestingAgentID(remoteClient));
         }
 
 
@@ -811,16 +791,14 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             // Security Checks are handled in the Groups Service.
 
-            GroupRequestID grID = GetClientGroupRequestID(remoteClient);
-
             switch ((OpenMetaverse.GroupRoleUpdate)updateType)
             {
                 case OpenMetaverse.GroupRoleUpdate.Create:
-                    m_groupData.AddGroupRole(grID, groupID, UUID.Random(), name, description, title, powers);
+                    m_groupData.AddGroupRole(GetRequestingAgentID(remoteClient), groupID, UUID.Random(), name, description, title, powers);
                     break;
 
                 case OpenMetaverse.GroupRoleUpdate.Delete:
-                    m_groupData.RemoveGroupRole(grID, groupID, roleID);
+                    m_groupData.RemoveGroupRole(GetRequestingAgentID(remoteClient), groupID, roleID);
                     break;
 
                 case OpenMetaverse.GroupRoleUpdate.UpdateAll:
@@ -831,7 +809,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                         GroupPowers gp = (GroupPowers)powers;
                         m_log.DebugFormat("[GROUPS]: Role ({0}) updated with Powers ({1}) ({2})", name, powers.ToString(), gp.ToString());
                     }
-                    m_groupData.UpdateGroupRole(grID, groupID, roleID, name, description, title, powers);
+                    m_groupData.UpdateGroupRole(GetRequestingAgentID(remoteClient), groupID, roleID, name, description, title, powers);
                     break;
 
                 case OpenMetaverse.GroupRoleUpdate.NoUpdate:
@@ -842,7 +820,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             }
 
             // TODO: This update really should send out updates for everyone in the role that just got changed.
-            SendAgentGroupDataUpdate(remoteClient, remoteClient.AgentId);
+            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
         }
 
         public void GroupRoleChanges(IClientAPI remoteClient, UUID groupID, UUID roleID, UUID memberID, uint changes)
@@ -850,18 +828,16 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
             // Todo: Security check
 
-            GroupRequestID grID = GetClientGroupRequestID(remoteClient);
-
             switch (changes)
             {
                 case 0:
                     // Add
-                    m_groupData.AddAgentToGroupRole(grID, memberID, groupID, roleID);
+                    m_groupData.AddAgentToGroupRole(GetRequestingAgentID(remoteClient), memberID, groupID, roleID);
 
                     break;
                 case 1:
                     // Remove
-                    m_groupData.RemoveAgentFromGroupRole(grID, memberID, groupID, roleID);
+                    m_groupData.RemoveAgentFromGroupRole(GetRequestingAgentID(remoteClient), memberID, groupID, roleID);
                     
                     break;
                 default:
@@ -870,25 +846,23 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             }
 
             // TODO: This update really should send out updates for everyone in the role that just got changed.
-            SendAgentGroupDataUpdate(remoteClient, remoteClient.AgentId);
+            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
         }
 
         public void GroupNoticeRequest(IClientAPI remoteClient, UUID groupNoticeID)
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            GroupRequestID grID = GetClientGroupRequestID(remoteClient);
-
-            GroupNoticeInfo data = m_groupData.GetGroupNotice(grID, groupNoticeID);
+            GroupNoticeInfo data = m_groupData.GetGroupNotice(GetRequestingAgentID(remoteClient), groupNoticeID);
 
             if (data != null)
             {
-                GroupRecord groupInfo = m_groupData.GetGroupRecord(grID, data.GroupID, null);
+                GroupRecord groupInfo = m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), data.GroupID, null);
 
                 GridInstantMessage msg = new GridInstantMessage();
                 msg.imSessionID = UUID.Zero.Guid;
                 msg.fromAgentID = data.GroupID.Guid;
-                msg.toAgentID = remoteClient.AgentId.Guid;
+                msg.toAgentID = GetRequestingAgentID(remoteClient).Guid;
                 msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
                 msg.fromAgentName = "Group Notice : " + groupInfo == null ? "Unknown" : groupInfo.GroupName;
                 msg.message = data.noticeData.Subject + "|" + data.Message;
@@ -900,7 +874,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                 msg.RegionID = UUID.Zero.Guid;
                 msg.binaryBucket = data.BinaryBucket;
 
-                OutgoingInstantMessage(msg, remoteClient.AgentId);
+                OutgoingInstantMessage(msg, GetRequestingAgentID(remoteClient));
             }
 
         }
@@ -920,7 +894,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             msg.Position = Vector3.Zero;
             msg.RegionID = UUID.Zero.Guid;
 
-            GroupNoticeInfo info = m_groupData.GetGroupNotice(null, groupNoticeID);
+            GroupNoticeInfo info = m_groupData.GetGroupNotice(agentID, groupNoticeID);
             if (info != null)
             {
                 msg.fromAgentID = info.GroupID.Guid;
@@ -947,7 +921,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
             // Send agent information about his groups
-            SendAgentGroupDataUpdate(remoteClient, remoteClient.AgentId);
+            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
         }
 
         public void JoinGroupRequest(IClientAPI remoteClient, UUID groupID)
@@ -955,19 +929,19 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
             // Should check to see if OpenEnrollment, or if there's an outstanding invitation
-            m_groupData.AddAgentToGroup(GetClientGroupRequestID(remoteClient), remoteClient.AgentId, groupID, UUID.Zero);
+            m_groupData.AddAgentToGroup(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID, UUID.Zero);
 
             remoteClient.SendJoinGroupReply(groupID, true);
 
             // Should this send updates to everyone in the group?
-            SendAgentGroupDataUpdate(remoteClient, remoteClient.AgentId);
+            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
         }
 
         public void LeaveGroupRequest(IClientAPI remoteClient, UUID groupID)
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            m_groupData.RemoveAgentFromGroup(GetClientGroupRequestID(remoteClient), remoteClient.AgentId, groupID);
+            m_groupData.RemoveAgentFromGroup(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);
 
             remoteClient.SendLeaveGroupReply(groupID, true);
 
@@ -975,21 +949,20 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             // SL sends out notifcations to the group messaging session that the person has left
             // Should this also update everyone who is in the group?
-            SendAgentGroupDataUpdate(remoteClient, remoteClient.AgentId);
+            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
         }
 
         public void EjectGroupMemberRequest(IClientAPI remoteClient, UUID groupID, UUID ejecteeID)
         {
             if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            GroupRequestID grID = GetClientGroupRequestID(remoteClient);
 
             // Todo: Security check?
-            m_groupData.RemoveAgentFromGroup(grID, ejecteeID, groupID);
+            m_groupData.RemoveAgentFromGroup(GetRequestingAgentID(remoteClient), ejecteeID, groupID);
 
-            remoteClient.SendEjectGroupMemberReply(remoteClient.AgentId, groupID, true);
+            remoteClient.SendEjectGroupMemberReply(GetRequestingAgentID(remoteClient), groupID, true);
 
-            GroupRecord groupInfo = m_groupData.GetGroupRecord(grID, groupID, null);
+            GroupRecord groupInfo = m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), groupID, null);
             UserProfileData userProfile = m_sceneList[0].CommsManager.UserService.GetUserProfile(ejecteeID);
 
             if ((groupInfo == null) || (userProfile == null))
@@ -1002,7 +975,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             GridInstantMessage msg = new GridInstantMessage();
             
             msg.imSessionID = UUID.Zero.Guid;
-            msg.fromAgentID = remoteClient.AgentId.Guid;
+            msg.fromAgentID = GetRequestingAgentID(remoteClient).Guid;
             // msg.fromAgentID = info.GroupID;
             msg.toAgentID = ejecteeID.Guid;
             //msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
@@ -1028,8 +1001,8 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             msg = new GridInstantMessage();
             msg.imSessionID = UUID.Zero.Guid;
-            msg.fromAgentID = remoteClient.AgentId.Guid;
-            msg.toAgentID = remoteClient.AgentId.Guid;
+            msg.fromAgentID = GetRequestingAgentID(remoteClient).Guid;
+            msg.toAgentID = GetRequestingAgentID(remoteClient).Guid;
             msg.timestamp = 0;
             msg.fromAgentName = remoteClient.Name;
             if (userProfile != null)
@@ -1047,7 +1020,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             msg.Position = Vector3.Zero;
             msg.RegionID = remoteClient.Scene.RegionInfo.RegionID.Guid;
             msg.binaryBucket = new byte[0];
-            OutgoingInstantMessage(msg, remoteClient.AgentId);
+            OutgoingInstantMessage(msg, GetRequestingAgentID(remoteClient));
 
 
             // SL sends out messages to everyone in the group
@@ -1057,17 +1030,26 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         public void InviteGroupRequest(IClientAPI remoteClient, UUID groupID, UUID invitedAgentID, UUID roleID)
         {
-            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+            if (m_debugEnabled)
+            {
+                m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+                m_log.DebugFormat("[GROUPS]: remoteClient({0}) groupID({0}) invitedAgentID({0}) roleID({0})", remoteClient, groupID, invitedAgentID, roleID);
+            }
+
 
             // Todo: Security check, probably also want to send some kind of notification
             UUID InviteID = UUID.Random();
-            GroupRequestID grid = GetClientGroupRequestID(remoteClient);
 
-            m_groupData.AddAgentToGroupInvite(grid, InviteID, groupID, roleID, invitedAgentID);
+            UUID requestingAgentID = GetRequestingAgentID(remoteClient);
+            if (requestingAgentID == UUID.Zero)
+            {
+                m_log.Error("[GROUPS] Group Invite Requires a valid requesting agent to be specified");
+            }
+            m_groupData.AddAgentToGroupInvite(requestingAgentID, InviteID, groupID, roleID, invitedAgentID);
 
             // Check to see if the invite went through, if it did not then it's possible
             // the remoteClient did not validate or did not have permission to invite.
-            GroupInviteInfo inviteInfo = m_groupData.GetAgentToGroupInvite(grid, InviteID);
+            GroupInviteInfo inviteInfo = m_groupData.GetAgentToGroupInvite(GetRequestingAgentID(remoteClient), InviteID);
 
             if (inviteInfo != null)
             {
@@ -1079,7 +1061,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
                     msg.imSessionID = inviteUUID;
 
-                    // msg.fromAgentID = remoteClient.AgentId.Guid;
+                    // msg.fromAgentID = GetRequestingAgentID(remoteClient).Guid;
                     msg.fromAgentID = groupID.Guid;
                     msg.toAgentID = invitedAgentID.Guid;
                     //msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
@@ -1132,57 +1114,6 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             return child;
         }
 
-        private GroupRequestID GetClientGroupRequestID(IClientAPI client)
-        {
-            if (client == null)
-            {
-                return new GroupRequestID();
-            }
-
-            lock (m_clientRequestIDInfo)
-            {
-                if (!m_clientRequestIDInfo.ContainsKey(client.AgentId))
-                {
-                    GroupRequestIDInfo info = new GroupRequestIDInfo();
-                    info.RequestID.AgentID = client.AgentId;
-                    info.RequestID.SessionID = client.SessionId;
-
-                    UserProfileData userProfile = m_sceneList[0].CommsManager.UserService.GetUserProfile(client.AgentId);
-                    if (userProfile == null)
-                    {
-                        // This should be impossible.  If I've been passed a reference to a client
-                        // that client should be registered with the UserService.  So something
-                        // is horribly wrong somewhere.
-
-                        m_log.WarnFormat("[GROUPS]: Could not find a user profile for {0} / {1}", client.Name, client.AgentId);
-
-                        // Default to local user service and hope for the best?
-                        info.RequestID.UserServiceURL = m_sceneList[0].CommsManager.NetworkServersInfo.UserURL;
-
-                    }
-                    else if (userProfile is ForeignUserProfileData)
-                    {
-                        // They aren't from around here
-                        ForeignUserProfileData fupd = (ForeignUserProfileData)userProfile;
-                        info.RequestID.UserServiceURL = fupd.UserServerURI;
-                    }
-                    else
-                    {
-                        // They're a local user, use this:
-                        info.RequestID.UserServiceURL = m_sceneList[0].CommsManager.NetworkServersInfo.UserURL;
-                    }
-
-                    m_clientRequestIDInfo.Add(client.AgentId, info);
-                }
-
-                m_clientRequestIDInfo[client.AgentId].LastUsedTMStamp = DateTime.Now;
-
-                return m_clientRequestIDInfo[client.AgentId].RequestID;
-            }
-// Unreachable code!
-//            return new GroupRequestID();
-        }
-
         /// <summary>
         /// Send 'remoteClient' the group membership 'data' for agent 'dataForAgentID'.
         /// </summary>
@@ -1231,6 +1162,11 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             llDataStruct.Add("GroupData", GroupData);
             llDataStruct.Add("NewGroupData", NewGroupData);
 
+            if (m_debugEnabled)
+            {
+                m_log.InfoFormat("[GROUPS]: {0}", OSDParser.SerializeJsonString(llDataStruct));
+            }
+
             IEventQueue queue = remoteClient.Scene.RequestModuleInterface<IEventQueue>();
 
             if (queue != null)
@@ -1308,7 +1244,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         /// <returns></returns>
         private GroupMembershipData[] GetProfileListedGroupMemberships(IClientAPI requestingClient, UUID dataForAgentID)
         {
-            List<GroupMembershipData> membershipData = m_groupData.GetAgentGroupMemberships(GetClientGroupRequestID(requestingClient), dataForAgentID);
+            List<GroupMembershipData> membershipData = m_groupData.GetAgentGroupMemberships(requestingClient.AgentId, dataForAgentID);
             GroupMembershipData[] membershipArray;
 
             if (requestingClient.AgentId != dataForAgentID)
@@ -1330,7 +1266,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                 m_log.InfoFormat("[GROUPS]: Get group membership information for {0} requested by {1}", dataForAgentID, requestingClient.AgentId);
                 foreach (GroupMembershipData membership in membershipArray)
                 {
-                    m_log.InfoFormat("[GROUPS]: {0} :: {1} - {2}", dataForAgentID, membership.GroupName, membership.GroupTitle);
+                    m_log.InfoFormat("[GROUPS]: {0} :: {1} - {2} - {3}", dataForAgentID, membership.GroupName, membership.GroupTitle, membership.GroupPowers);
                 }
             }
 
@@ -1389,6 +1325,23 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         }
 
         #endregion
+
+        private UUID GetRequestingAgentID(IClientAPI client)
+        {
+            UUID requestingAgentID = UUID.Zero;
+            if (client != null)
+            {
+                requestingAgentID = client.AgentId;
+            }
+            return requestingAgentID;
+        }
     }
 
+    public class GroupNoticeInfo
+    {
+        public GroupNoticeData noticeData = new GroupNoticeData();
+        public UUID GroupID = UUID.Zero;
+        public string Message = string.Empty;
+        public byte[] BinaryBucket = new byte[0];
+    }
 }
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/IGroupsServicesConnector.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/IGroupsServicesConnector.cs
index 9e0fa2d..a046e09 100644
--- a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/IGroupsServicesConnector.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/IGroupsServicesConnector.cs
@@ -36,42 +36,47 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 {
     interface IGroupsServicesConnector
     {
-        UUID CreateGroup(GroupRequestID requestID, string name, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish, UUID founderID);
-        void UpdateGroup(GroupRequestID requestID, UUID groupID, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish);
-        GroupRecord GetGroupRecord(GroupRequestID requestID, UUID GroupID, string GroupName);
-        List<DirGroupsReplyData> FindGroups(GroupRequestID requestID, string search);
-        List<GroupMembersData> GetGroupMembers(GroupRequestID requestID, UUID GroupID);
+        UUID CreateGroup(UUID RequestingAgentID, string name, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish, UUID founderID);
+        void UpdateGroup(UUID RequestingAgentID, UUID groupID, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish);
+        GroupRecord GetGroupRecord(UUID RequestingAgentID, UUID GroupID, string GroupName);
+        List<DirGroupsReplyData> FindGroups(UUID RequestingAgentID, string search);
+        List<GroupMembersData> GetGroupMembers(UUID RequestingAgentID, UUID GroupID);
 
-        void AddGroupRole(GroupRequestID requestID, UUID groupID, UUID roleID, string name, string description, string title, ulong powers);
-        void UpdateGroupRole(GroupRequestID requestID, UUID groupID, UUID roleID, string name, string description, string title, ulong powers);
-        void RemoveGroupRole(GroupRequestID requestID, UUID groupID, UUID roleID);
-        List<GroupRolesData> GetGroupRoles(GroupRequestID requestID, UUID GroupID);
-        List<GroupRoleMembersData> GetGroupRoleMembers(GroupRequestID requestID, UUID GroupID);
+        void AddGroupRole(UUID RequestingAgentID, UUID groupID, UUID roleID, string name, string description, string title, ulong powers);
+        void UpdateGroupRole(UUID RequestingAgentID, UUID groupID, UUID roleID, string name, string description, string title, ulong powers);
+        void RemoveGroupRole(UUID RequestingAgentID, UUID groupID, UUID roleID);
+        List<GroupRolesData> GetGroupRoles(UUID RequestingAgentID, UUID GroupID);
+        List<GroupRoleMembersData> GetGroupRoleMembers(UUID RequestingAgentID, UUID GroupID);
 
-        void AddAgentToGroup(GroupRequestID requestID, UUID AgentID, UUID GroupID, UUID RoleID);
-        void RemoveAgentFromGroup(GroupRequestID requestID, UUID AgentID, UUID GroupID);
+        void AddAgentToGroup(UUID RequestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID);
+        void RemoveAgentFromGroup(UUID RequestingAgentID, UUID AgentID, UUID GroupID);
 
-        void AddAgentToGroupInvite(GroupRequestID requestID, UUID inviteID, UUID groupID, UUID roleID, UUID agentID);
-        GroupInviteInfo GetAgentToGroupInvite(GroupRequestID requestID, UUID inviteID);
-        void RemoveAgentToGroupInvite(GroupRequestID requestID, UUID inviteID);
+        void AddAgentToGroupInvite(UUID RequestingAgentID, UUID inviteID, UUID groupID, UUID roleID, UUID agentID);
+        GroupInviteInfo GetAgentToGroupInvite(UUID RequestingAgentID, UUID inviteID);
+        void RemoveAgentToGroupInvite(UUID RequestingAgentID, UUID inviteID);
 
+        void AddAgentToGroupRole(UUID RequestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID);
+        void RemoveAgentFromGroupRole(UUID RequestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID);
+        List<GroupRolesData> GetAgentGroupRoles(UUID RequestingAgentID, UUID AgentID, UUID GroupID);
 
-        void AddAgentToGroupRole(GroupRequestID requestID, UUID AgentID, UUID GroupID, UUID RoleID);
-        void RemoveAgentFromGroupRole(GroupRequestID requestID, UUID AgentID, UUID GroupID, UUID RoleID);
-        List<GroupRolesData> GetAgentGroupRoles(GroupRequestID requestID, UUID AgentID, UUID GroupID);
+        void SetAgentActiveGroup(UUID RequestingAgentID, UUID AgentID, UUID GroupID);
+        GroupMembershipData GetAgentActiveMembership(UUID RequestingAgentID, UUID AgentID);
 
-        void SetAgentActiveGroup(GroupRequestID requestID, UUID AgentID, UUID GroupID);
-        GroupMembershipData GetAgentActiveMembership(GroupRequestID requestID, UUID AgentID);
+        void SetAgentActiveGroupRole(UUID RequestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID);
+        void SetAgentGroupInfo(UUID RequestingAgentID, UUID AgentID, UUID GroupID, bool AcceptNotices, bool ListInProfile);
 
-        void SetAgentActiveGroupRole(GroupRequestID requestID, UUID AgentID, UUID GroupID, UUID RoleID);
-        void SetAgentGroupInfo(GroupRequestID requestID, UUID AgentID, UUID GroupID, bool AcceptNotices, bool ListInProfile);
+        GroupMembershipData GetAgentGroupMembership(UUID RequestingAgentID, UUID AgentID, UUID GroupID);
+        List<GroupMembershipData> GetAgentGroupMemberships(UUID RequestingAgentID, UUID AgentID);
 
-        GroupMembershipData GetAgentGroupMembership(GroupRequestID requestID, UUID AgentID, UUID GroupID);
-        List<GroupMembershipData> GetAgentGroupMemberships(GroupRequestID requestID, UUID AgentID);
+        void AddGroupNotice(UUID RequestingAgentID, UUID groupID, UUID noticeID, string fromName, string subject, string message, byte[] binaryBucket);
+        GroupNoticeInfo GetGroupNotice(UUID RequestingAgentID, UUID noticeID);
+        List<GroupNoticeData> GetGroupNotices(UUID RequestingAgentID, UUID GroupID);
 
-        void AddGroupNotice(GroupRequestID requestID, UUID groupID, UUID noticeID, string fromName, string subject, string message, byte[] binaryBucket);
-        GroupNoticeInfo GetGroupNotice(GroupRequestID requestID, UUID noticeID);
-        List<GroupNoticeData> GetGroupNotices(GroupRequestID requestID, UUID GroupID);
+        void ResetAgentGroupChatSessions(UUID agentID);
+        bool hasAgentBeenInvitedToGroupChatSession(UUID agentID, UUID groupID);
+        bool hasAgentDroppedGroupChatSession(UUID agentID, UUID groupID);
+        void AgentDroppedFromGroupChatSession(UUID agentID, UUID groupID);
+        void AgentInvitedToGroupChatSession(UUID agentID, UUID groupID);
     }
 
     public class GroupInviteInfo
@@ -81,11 +86,4 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         public UUID AgentID  = UUID.Zero;
         public UUID InviteID = UUID.Zero;
     }
-
-    public class GroupRequestID
-    {
-        public UUID AgentID = UUID.Zero;
-        public string UserServiceURL = string.Empty;
-        public UUID SessionID = UUID.Zero;
-    }
 }
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/XmlRpcGroupsServicesConnectorModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/XmlRpcGroupsServicesConnectorModule.cs
index 964d0bb..861731c 100644
--- a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/XmlRpcGroupsServicesConnectorModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/XmlRpcGroupsServicesConnectorModule.cs
@@ -40,6 +40,7 @@ using OpenMetaverse;
 using OpenMetaverse.StructuredData;
 
 using OpenSim.Framework;
+using OpenSim.Framework.Communications;
 using OpenSim.Region.Framework.Interfaces;
 
 namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
@@ -47,9 +48,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
     public class XmlRpcGroupsServicesConnectorModule : ISharedRegionModule, IGroupsServicesConnector
     {
-        private static readonly ILog m_log =
-            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         public const GroupPowers m_DefaultEveryonePowers = GroupPowers.AllowSetHome | 
             GroupPowers.Accountable | 
@@ -61,13 +60,26 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         private bool m_connectorEnabled = false;
 
-        private string m_serviceURL = string.Empty;
+        private string m_groupsServerURI = string.Empty;
 
         private bool m_disableKeepAlive = false;
 
         private string m_groupReadKey  = string.Empty;
         private string m_groupWriteKey = string.Empty;
 
+        private IUserService m_userService = null;
+        private CommunicationsManager m_commManager = null;
+
+        private bool m_debugEnabled = false;
+
+
+        // Used to track which agents are have dropped from a group chat session
+        // Should be reset per agent, on logon
+        // TODO: move this to Flotsam XmlRpc Service
+        // SessionID, List<AgentID>
+        private Dictionary<UUID, List<UUID>> m_groupsAgentsDroppedFromChatSession = new Dictionary<UUID, List<UUID>>();
+        private Dictionary<UUID, List<UUID>> m_groupsAgentsInvitedToChatSession = new Dictionary<UUID, List<UUID>>();
+
 
         #region IRegionModuleBase Members
 
@@ -104,11 +116,11 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
                 m_log.InfoFormat("[GROUPS-CONNECTOR]: Initializing {0}", this.Name);
 
-                m_serviceURL = groupsConfig.GetString("XmlRpcServiceURL", string.Empty);
-                if ((m_serviceURL == null) ||
-                    (m_serviceURL == string.Empty))
+                m_groupsServerURI = groupsConfig.GetString("GroupsServerURI", groupsConfig.GetString("XmlRpcServiceURL", string.Empty));
+                if ((m_groupsServerURI == null) ||
+                    (m_groupsServerURI == string.Empty))
                 {
-                    m_log.ErrorFormat("Please specify a valid URL for XmlRpcServiceURL in OpenSim.ini, [Groups]");
+                    m_log.ErrorFormat("Please specify a valid URL for GroupsServerURI in OpenSim.ini, [Groups]");
                     m_connectorEnabled = false;
                     return;
                 }
@@ -118,6 +130,9 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                 m_groupReadKey = groupsConfig.GetString("XmlRpcServiceReadKey", string.Empty);
                 m_groupWriteKey = groupsConfig.GetString("XmlRpcServiceWriteKey", string.Empty);
 
+                m_debugEnabled = groupsConfig.GetBoolean("DebugEnabled", true);
+
+
                 // If we got all the config options we need, lets start'er'up
                 m_connectorEnabled = true;
             }
@@ -131,13 +146,23 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         public void AddRegion(OpenSim.Region.Framework.Scenes.Scene scene)
         {
             if (m_connectorEnabled)
+            {
                 scene.RegisterModuleInterface<IGroupsServicesConnector>(this);
+
+                if (m_userService == null)
+                {
+                    m_userService = scene.CommsManager.UserService;
+                    m_commManager = scene.CommsManager;
+                }
+            }
         }
 
         public void RemoveRegion(OpenSim.Region.Framework.Scenes.Scene scene)
         {
             if (scene.RequestModuleInterface<IGroupsServicesConnector>() == this)
+            {
                 scene.UnregisterModuleInterface<IGroupsServicesConnector>(this);
+            }
         }
 
         public void RegionLoaded(OpenSim.Region.Framework.Scenes.Scene scene)
@@ -157,14 +182,12 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         #endregion
 
-
-
         #region IGroupsServicesConnector Members
 
         /// <summary>
         /// Create a Group, including Everyone and Owners Role, place FounderID in both groups, select Owner as selected role, and newly created group as agent's active role.
         /// </summary>
-        public UUID CreateGroup(GroupRequestID requestID, string name, string charter, bool showInList, UUID insigniaID, 
+        public UUID CreateGroup(UUID requestingAgentID, string name, string charter, bool showInList, UUID insigniaID, 
                                 int membershipFee, bool openEnrollment, bool allowPublish, 
                                 bool maturePublish, UUID founderID)
         {
@@ -236,7 +259,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
 
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.createGroup", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.createGroup", param);
 
             if (respData.Contains("error"))
             {
@@ -248,7 +271,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             return UUID.Parse((string)respData["GroupID"]);
         }
 
-        public void UpdateGroup(GroupRequestID requestID, UUID groupID, string charter, bool showInList, 
+        public void UpdateGroup(UUID requestingAgentID, UUID groupID, string charter, bool showInList, 
                                 UUID insigniaID, int membershipFee, bool openEnrollment, 
                                 bool allowPublish, bool maturePublish)
         {
@@ -262,10 +285,10 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             param["AllowPublish"] = allowPublish == true ? 1 : 0;
             param["MaturePublish"] = maturePublish == true ? 1 : 0;
 
-            XmlRpcCall(requestID, "groups.updateGroup", param);
+            XmlRpcCall(requestingAgentID, "groups.updateGroup", param);
         }
 
-        public void AddGroupRole(GroupRequestID requestID, UUID groupID, UUID roleID, string name, string description, 
+        public void AddGroupRole(UUID requestingAgentID, UUID groupID, UUID roleID, string name, string description, 
                                  string title, ulong powers)
         {
             Hashtable param = new Hashtable();
@@ -276,19 +299,19 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             param["Title"] = title;
             param["Powers"] = powers.ToString();
 
-            XmlRpcCall(requestID, "groups.addRoleToGroup", param);
+            XmlRpcCall(requestingAgentID, "groups.addRoleToGroup", param);
         }
 
-        public void RemoveGroupRole(GroupRequestID requestID, UUID groupID, UUID roleID)
+        public void RemoveGroupRole(UUID requestingAgentID, UUID groupID, UUID roleID)
         {
             Hashtable param = new Hashtable();
             param["GroupID"] = groupID.ToString();
             param["RoleID"] = roleID.ToString();
 
-            XmlRpcCall(requestID, "groups.removeRoleFromGroup", param);
+            XmlRpcCall(requestingAgentID, "groups.removeRoleFromGroup", param);
         }
 
-        public void UpdateGroupRole(GroupRequestID requestID, UUID groupID, UUID roleID, string name, string description, 
+        public void UpdateGroupRole(UUID requestingAgentID, UUID groupID, UUID roleID, string name, string description, 
                                     string title, ulong powers)
         {
             Hashtable param = new Hashtable();
@@ -308,10 +331,10 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             }
             param["Powers"] = powers.ToString();
 
-            XmlRpcCall(requestID, "groups.updateGroupRole", param);
+            XmlRpcCall(requestingAgentID, "groups.updateGroupRole", param);
         }
 
-        public GroupRecord GetGroupRecord(GroupRequestID requestID, UUID GroupID, string GroupName)
+        public GroupRecord GetGroupRecord(UUID requestingAgentID, UUID GroupID, string GroupName)
         {
             Hashtable param = new Hashtable();
             if (GroupID != UUID.Zero)
@@ -323,7 +346,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                 param["Name"] = GroupName.ToString();
             }
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.getGroup", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroup", param);
 
             if (respData.Contains("error"))
             {
@@ -334,12 +357,12 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         }
 
-        public GroupProfileData GetMemberGroupProfile(GroupRequestID requestID, UUID GroupID, UUID AgentID)
+        public GroupProfileData GetMemberGroupProfile(UUID requestingAgentID, UUID GroupID, UUID AgentID)
         {
             Hashtable param = new Hashtable();
             param["GroupID"] = GroupID.ToString();
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.getGroup", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroup", param);
 
             if (respData.Contains("error"))
             {
@@ -347,38 +370,35 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                 return new GroupProfileData();
             }
 
-            GroupMembershipData MemberInfo = GetAgentGroupMembership(requestID, AgentID, GroupID);
+            GroupMembershipData MemberInfo = GetAgentGroupMembership(requestingAgentID, AgentID, GroupID);
             GroupProfileData MemberGroupProfile = GroupProfileHashtableToGroupProfileData(respData);
 
             MemberGroupProfile.MemberTitle = MemberInfo.GroupTitle;
             MemberGroupProfile.PowersMask = MemberInfo.GroupPowers;
 
             return MemberGroupProfile;
-
         }
 
-
-
-        public void SetAgentActiveGroup(GroupRequestID requestID, UUID AgentID, UUID GroupID)
+        public void SetAgentActiveGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID)
         {
             Hashtable param = new Hashtable();
             param["AgentID"] = AgentID.ToString();
             param["GroupID"] = GroupID.ToString();
 
-            XmlRpcCall(requestID, "groups.setAgentActiveGroup", param);
+            XmlRpcCall(requestingAgentID, "groups.setAgentActiveGroup", param);
         }
 
-        public void SetAgentActiveGroupRole(GroupRequestID requestID, UUID AgentID, UUID GroupID, UUID RoleID)
+        public void SetAgentActiveGroupRole(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)
         {
             Hashtable param = new Hashtable();
             param["AgentID"] = AgentID.ToString();
             param["GroupID"] = GroupID.ToString();
             param["SelectedRoleID"] = RoleID.ToString();
 
-            XmlRpcCall(requestID, "groups.setAgentGroupInfo", param);
+            XmlRpcCall(requestingAgentID, "groups.setAgentGroupInfo", param);
         }
 
-        public void SetAgentGroupInfo(GroupRequestID requestID, UUID AgentID, UUID GroupID, bool AcceptNotices, bool ListInProfile)
+        public void SetAgentGroupInfo(UUID requestingAgentID, UUID AgentID, UUID GroupID, bool AcceptNotices, bool ListInProfile)
         {
             Hashtable param = new Hashtable();
             param["AgentID"] = AgentID.ToString();
@@ -386,11 +406,11 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             param["AcceptNotices"] = AcceptNotices ? "1" : "0";
             param["ListInProfile"] = ListInProfile ? "1" : "0";
 
-            XmlRpcCall(requestID, "groups.setAgentGroupInfo", param);
+            XmlRpcCall(requestingAgentID, "groups.setAgentGroupInfo", param);
 
         }
 
-        public void AddAgentToGroupInvite(GroupRequestID requestID, UUID inviteID, UUID groupID, UUID roleID, UUID agentID)
+        public void AddAgentToGroupInvite(UUID requestingAgentID, UUID inviteID, UUID groupID, UUID roleID, UUID agentID)
         {
             Hashtable param = new Hashtable();
             param["InviteID"] = inviteID.ToString();
@@ -398,16 +418,16 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             param["RoleID"] = roleID.ToString();
             param["GroupID"] = groupID.ToString();
 
-            XmlRpcCall(requestID, "groups.addAgentToGroupInvite", param);
+            XmlRpcCall(requestingAgentID, "groups.addAgentToGroupInvite", param);
 
         }
 
-        public GroupInviteInfo GetAgentToGroupInvite(GroupRequestID requestID, UUID inviteID)
+        public GroupInviteInfo GetAgentToGroupInvite(UUID requestingAgentID, UUID inviteID)
         {
             Hashtable param = new Hashtable();
             param["InviteID"] = inviteID.ToString();
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.getAgentToGroupInvite", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentToGroupInvite", param);
 
             if (respData.Contains("error"))
             {
@@ -423,60 +443,59 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             return inviteInfo;
         }
 
-        public void RemoveAgentToGroupInvite(GroupRequestID requestID, UUID inviteID)
+        public void RemoveAgentToGroupInvite(UUID requestingAgentID, UUID inviteID)
         {
             Hashtable param = new Hashtable();
             param["InviteID"] = inviteID.ToString();
 
-            XmlRpcCall(requestID, "groups.removeAgentToGroupInvite", param);
+            XmlRpcCall(requestingAgentID, "groups.removeAgentToGroupInvite", param);
         }
 
-        public void AddAgentToGroup(GroupRequestID requestID, UUID AgentID, UUID GroupID, UUID RoleID)
+        public void AddAgentToGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)
         {
             Hashtable param = new Hashtable();
             param["AgentID"] = AgentID.ToString();
             param["GroupID"] = GroupID.ToString();
             param["RoleID"] = RoleID.ToString();
 
-            XmlRpcCall(requestID, "groups.addAgentToGroup", param);
+            XmlRpcCall(requestingAgentID, "groups.addAgentToGroup", param);
         }
 
-        public void RemoveAgentFromGroup(GroupRequestID requestID, UUID AgentID, UUID GroupID)
+        public void RemoveAgentFromGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID)
         {
             Hashtable param = new Hashtable();
             param["AgentID"] = AgentID.ToString();
             param["GroupID"] = GroupID.ToString();
 
-            XmlRpcCall(requestID, "groups.removeAgentFromGroup", param);
+            XmlRpcCall(requestingAgentID, "groups.removeAgentFromGroup", param);
         }
 
-        public void AddAgentToGroupRole(GroupRequestID requestID, UUID AgentID, UUID GroupID, UUID RoleID)
+        public void AddAgentToGroupRole(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)
         {
             Hashtable param = new Hashtable();
             param["AgentID"] = AgentID.ToString();
             param["GroupID"] = GroupID.ToString();
             param["RoleID"] = RoleID.ToString();
 
-            XmlRpcCall(requestID, "groups.addAgentToGroupRole", param);
+            XmlRpcCall(requestingAgentID, "groups.addAgentToGroupRole", param);
         }
 
-        public void RemoveAgentFromGroupRole(GroupRequestID requestID, UUID AgentID, UUID GroupID, UUID RoleID)
+        public void RemoveAgentFromGroupRole(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)
         {
             Hashtable param = new Hashtable();
             param["AgentID"] = AgentID.ToString();
             param["GroupID"] = GroupID.ToString();
             param["RoleID"] = RoleID.ToString();
 
-            XmlRpcCall(requestID, "groups.removeAgentFromGroupRole", param);
+            XmlRpcCall(requestingAgentID, "groups.removeAgentFromGroupRole", param);
         }
 
-
-        public List<DirGroupsReplyData> FindGroups(GroupRequestID requestID, string search)
+        public List<DirGroupsReplyData> FindGroups(UUID requestingAgentID, string search)
         {
             Hashtable param = new Hashtable();
             param["Search"] = search;
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.findGroups", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.findGroups", param);
 
             List<DirGroupsReplyData> findings = new List<DirGroupsReplyData>();
 
@@ -498,13 +517,13 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             return findings;
         }
 
-        public GroupMembershipData GetAgentGroupMembership(GroupRequestID requestID, UUID AgentID, UUID GroupID)
+        public GroupMembershipData GetAgentGroupMembership(UUID requestingAgentID, UUID AgentID, UUID GroupID)
         {
             Hashtable param = new Hashtable();
             param["AgentID"] = AgentID.ToString();
             param["GroupID"] = GroupID.ToString();
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.getAgentGroupMembership", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentGroupMembership", param);
 
             if (respData.Contains("error"))
             {
@@ -516,12 +535,12 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             return data;
         }
 
-        public GroupMembershipData GetAgentActiveMembership(GroupRequestID requestID, UUID AgentID)
+        public GroupMembershipData GetAgentActiveMembership(UUID requestingAgentID, UUID AgentID)
         {
             Hashtable param = new Hashtable();
             param["AgentID"] = AgentID.ToString();
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.getAgentActiveMembership", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentActiveMembership", param);
 
             if (respData.Contains("error"))
             {
@@ -531,13 +550,12 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             return HashTableToGroupMembershipData(respData);
         }
 
-
-        public List<GroupMembershipData> GetAgentGroupMemberships(GroupRequestID requestID, UUID AgentID)
+        public List<GroupMembershipData> GetAgentGroupMemberships(UUID requestingAgentID, UUID AgentID)
         {
             Hashtable param = new Hashtable();
             param["AgentID"] = AgentID.ToString();
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.getAgentGroupMemberships", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentGroupMemberships", param);
 
             List<GroupMembershipData> memberships = new List<GroupMembershipData>();
 
@@ -552,13 +570,13 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             return memberships;
         }
 
-        public List<GroupRolesData> GetAgentGroupRoles(GroupRequestID requestID, UUID AgentID, UUID GroupID)
+        public List<GroupRolesData> GetAgentGroupRoles(UUID requestingAgentID, UUID AgentID, UUID GroupID)
         {
             Hashtable param = new Hashtable();
             param["AgentID"] = AgentID.ToString();
             param["GroupID"] = GroupID.ToString();
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.getAgentRoles", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentRoles", param);
 
             List<GroupRolesData> Roles = new List<GroupRolesData>();
 
@@ -584,12 +602,12 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         }
 
-        public List<GroupRolesData> GetGroupRoles(GroupRequestID requestID, UUID GroupID)
+        public List<GroupRolesData> GetGroupRoles(UUID requestingAgentID, UUID GroupID)
         {
             Hashtable param = new Hashtable();
             param["GroupID"] = GroupID.ToString();
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.getGroupRoles", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupRoles", param);
 
             List<GroupRolesData> Roles = new List<GroupRolesData>();
 
@@ -617,12 +635,12 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
 
 
-        public List<GroupMembersData> GetGroupMembers(GroupRequestID requestID, UUID GroupID)
+        public List<GroupMembersData> GetGroupMembers(UUID requestingAgentID, UUID GroupID)
         {
             Hashtable param = new Hashtable();
             param["GroupID"] = GroupID.ToString();
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.getGroupMembers", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupMembers", param);
 
             List<GroupMembersData> members = new List<GroupMembersData>();
 
@@ -650,12 +668,12 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         }
 
-        public List<GroupRoleMembersData> GetGroupRoleMembers(GroupRequestID requestID, UUID GroupID)
+        public List<GroupRoleMembersData> GetGroupRoleMembers(UUID requestingAgentID, UUID GroupID)
         {
             Hashtable param = new Hashtable();
             param["GroupID"] = GroupID.ToString();
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.getGroupRoleMembers", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupRoleMembers", param);
 
             List<GroupRoleMembersData> members = new List<GroupRoleMembersData>();
 
@@ -674,12 +692,12 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             return members;
         }
 
-        public List<GroupNoticeData> GetGroupNotices(GroupRequestID requestID, UUID GroupID)
+        public List<GroupNoticeData> GetGroupNotices(UUID requestingAgentID, UUID GroupID)
         {
             Hashtable param = new Hashtable();
             param["GroupID"] = GroupID.ToString();
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.getGroupNotices", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupNotices", param);
 
             List<GroupNoticeData> values = new List<GroupNoticeData>();
 
@@ -701,12 +719,12 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             return values;
 
         }
-        public GroupNoticeInfo GetGroupNotice(GroupRequestID requestID, UUID noticeID)
+        public GroupNoticeInfo GetGroupNotice(UUID requestingAgentID, UUID noticeID)
         {
             Hashtable param = new Hashtable();
             param["NoticeID"] = noticeID.ToString();
 
-            Hashtable respData = XmlRpcCall(requestID, "groups.getGroupNotice", param);
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupNotice", param);
 
 
             if (respData.Contains("error"))
@@ -732,7 +750,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             return data;
         }
-        public void AddGroupNotice(GroupRequestID requestID, UUID groupID, UUID noticeID, string fromName, string subject, string message, byte[] binaryBucket)
+        public void AddGroupNotice(UUID requestingAgentID, UUID groupID, UUID noticeID, string fromName, string subject, string message, byte[] binaryBucket)
         {
             string binBucket = OpenMetaverse.Utils.BytesToHexString(binaryBucket, "");
 
@@ -745,7 +763,70 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             param["BinaryBucket"] = binBucket;
             param["TimeStamp"] = ((uint)Util.UnixTimeSinceEpoch()).ToString();
 
-            XmlRpcCall(requestID, "groups.addGroupNotice", param);
+            XmlRpcCall(requestingAgentID, "groups.addGroupNotice", param);
+        }
+
+
+
+        #endregion
+
+        #region GroupSessionTracking
+
+        public void ResetAgentGroupChatSessions(UUID agentID)
+        {
+            foreach (List<UUID> agentList in m_groupsAgentsDroppedFromChatSession.Values)
+            {
+                agentList.Remove(agentID);
+            }
+        }
+
+        public bool hasAgentBeenInvitedToGroupChatSession(UUID agentID, UUID groupID)
+        {
+            // If we're  tracking this group, and we can find them in the tracking, then they've been invited
+            return m_groupsAgentsInvitedToChatSession.ContainsKey(groupID)
+                && m_groupsAgentsInvitedToChatSession[groupID].Contains(agentID);
+        }
+
+        public bool hasAgentDroppedGroupChatSession(UUID agentID, UUID groupID)
+        {
+            // If we're tracking drops for this group, 
+            // and we find them, well... then they've dropped
+            return m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID) 
+                && m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID);
+        }
+
+        public void AgentDroppedFromGroupChatSession(UUID agentID, UUID groupID)
+        {
+            if (m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID))
+            {
+                // If not in dropped list, add
+                if (!m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID))
+                {
+                    m_groupsAgentsDroppedFromChatSession[groupID].Add(agentID);
+                }
+            }
+        }
+
+        public void AgentInvitedToGroupChatSession(UUID agentID, UUID groupID)
+        {
+            // Add Session Status if it doesn't exist for this session
+            CreateGroupChatSessionTracking(groupID);
+
+            // If nessesary, remove from dropped list
+            if (m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID))
+            {
+                m_groupsAgentsDroppedFromChatSession[groupID].Remove(agentID);
+            }
+        }
+
+        private void CreateGroupChatSessionTracking(UUID groupID)
+        {
+            if (!m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID))
+            {
+                m_groupsAgentsDroppedFromChatSession.Add(groupID, new List<UUID>());
+                m_groupsAgentsInvitedToChatSession.Add(groupID, new List<UUID>());
+            }
+
         }
         #endregion
 
@@ -778,7 +859,6 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         private GroupRecord GroupProfileHashtableToGroupRecord(Hashtable groupProfile)
         {
-
             GroupRecord group = new GroupRecord();
             group.GroupID = UUID.Parse((string)groupProfile["GroupID"]);
             group.GroupName = groupProfile["Name"].ToString();
@@ -797,6 +877,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             return group;
         }
+        
         private static GroupMembershipData HashTableToGroupMembershipData(Hashtable respData)
         {
             GroupMembershipData data = new GroupMembershipData();
@@ -829,6 +910,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             data.MembershipFee = int.Parse((string)respData["MembershipFee"]);
             data.OpenEnrollment = ((string)respData["OpenEnrollment"] == "1");
             data.ShowInList = ((string)respData["ShowInList"] == "1");
+            
             return data;
         }
 
@@ -837,20 +919,27 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
         /// <summary>
         /// Encapsulate the XmlRpc call to standardize security and error handling.
         /// </summary>
-        private Hashtable XmlRpcCall(GroupRequestID requestID, string function, Hashtable param)
+        private Hashtable XmlRpcCall(UUID requestingAgentID, string function, Hashtable param)
         {
-            if (requestID == null)
-            {
-                requestID = new GroupRequestID();
-            }
-            param.Add("RequestingAgentID", requestID.AgentID.ToString());
-            param.Add("RequestingAgentUserService", requestID.UserServiceURL);
-            param.Add("RequestingSessionID", requestID.SessionID.ToString());
+            string UserService;
+            UUID SessionID;
+            GetClientGroupRequestID(requestingAgentID, out UserService, out SessionID);
+            param.Add("RequestingAgentID", requestingAgentID.ToString());
+            param.Add("RequestingAgentUserService", UserService);
+            param.Add("RequestingSessionID", SessionID.ToString());
             
 
             param.Add("ReadKey", m_groupReadKey);
             param.Add("WriteKey", m_groupWriteKey);
 
+            if (m_debugEnabled)
+            {
+                m_log.Debug("[XMLRPCGROUPDATA] XmlRpcCall Params:");
+                foreach (string key in param.Keys)
+                {
+                    m_log.DebugFormat("[XMLRPCGROUPDATA] {0} : {1}", key, param[key]);
+                }
+            }
 
             IList parameters = new ArrayList();
             parameters.Add(param);
@@ -862,7 +951,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             try
             {
-                resp = req.Send(m_serviceURL, 10000);
+                resp = req.Send(m_groupsServerURI, 10000);
             }
             catch (Exception e)
             {
@@ -871,10 +960,13 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                 m_log.ErrorFormat("[XMLRPCGROUPDATA]: An error has occured while attempting to access the XmlRpcGroups server method: {0}", function);
                 m_log.ErrorFormat("[XMLRPCGROUPDATA]: {0} ", e.ToString());
 
-                foreach (string ResponseLine in req.RequestResponse.Split(new string[] { Environment.NewLine },StringSplitOptions.None))
+                if ((req != null) && (req.RequestResponse != null))
+                {
+                    foreach (string ResponseLine in req.RequestResponse.Split(new string[] { Environment.NewLine }, StringSplitOptions.None))
                 {
                     m_log.ErrorFormat("[XMLRPCGROUPDATA]: {0} ", ResponseLine);
                 }
+                }
 
                 foreach (string key in param.Keys)
                 {
@@ -886,12 +978,13 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
                 return respData;
             }
 
+
             if (resp.Value is Hashtable)
             {
                 Hashtable respData = (Hashtable)resp.Value;
                 if (respData.Contains("error") && !respData.Contains("succeed"))
                 {
-                    LogRespDataToConsoleError(respData);
+                    LogRespDataToConsoleError(function, respData);
                 }
 
                 return respData;
@@ -919,32 +1012,75 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             return error;
         }
 
-        private void LogRespDataToConsoleError(Hashtable respData)
+        private void LogRespDataToConsoleError(string function, Hashtable respData)
         {
+            m_log.ErrorFormat("[XMLRPCGROUPDATA]: Error data from XmlRpcGroups server method: {0}", function);
             m_log.Error("[XMLRPCGROUPDATA]: Error:");
 
             foreach (string key in respData.Keys)
             {
                 m_log.ErrorFormat("[XMLRPCGROUPDATA]: Key: {0}", key);
 
-                string[] lines = respData[key].ToString().Split(new char[] { '\n' });
-                foreach (string line in lines)
+                if ((respData != null) && (respData.ContainsKey(key)) && (respData[key]!=null))
                 {
-                    m_log.ErrorFormat("[XMLRPCGROUPDATA]: {0}", line);
+                    string[] lines = respData[key].ToString().Split(new char[] { '\n' });
+                    foreach (string line in lines)
+                    {
+                        m_log.ErrorFormat("[XMLRPCGROUPDATA]: {0}", line);
+                    }
+                }
+                else
+                {
+                    m_log.ErrorFormat("[XMLRPCGROUPDATA]: {0} : Empty/NULL", key);
                 }
 
             }
         }
 
+        
+        /// <summary>
+        /// Group Request Tokens are an attempt to allow the groups service to authenticate 
+        /// requests.  
+        /// TODO: This broke after the big grid refactor, either find a better way, or discard this
+        /// </summary>
+        /// <param name="client"></param>
+        /// <returns></returns>
+        private void GetClientGroupRequestID(UUID AgentID, out string UserServiceURL, out UUID SessionID)
+        {
+            // Default to local grid user service
+            UserServiceURL = m_commManager.NetworkServersInfo.UserURL; ;
 
-    }
+            // if AgentID == UUID, there will be no SessionID.  This will be true when
+            // the region is requesting information for region use (object permissions for example)
+            SessionID = UUID.Zero;
 
-    public class GroupNoticeInfo
-    {
-        public GroupNoticeData noticeData = new GroupNoticeData();
-        public UUID GroupID = UUID.Zero;
-        public string Message = string.Empty;
-        public byte[] BinaryBucket = new byte[0];
+            // Attempt to get User Profile, for  SessionID
+            UserProfileData userProfile = m_userService.GetUserProfile(AgentID);
+
+            if ((userProfile != null) && (userProfile is ForeignUserProfileData))
+            {
+                // They aren't from around here
+                ForeignUserProfileData fupd = (ForeignUserProfileData)userProfile;
+                UserServiceURL = fupd.UserServerURI;
+                SessionID = fupd.CurrentAgent.SessionID;
+
+            }
+            else if (userProfile != null)
+            {
+                // Local, just use the local SessionID
+                SessionID = userProfile.CurrentAgent.SessionID;
+            }
+            else if (AgentID != UUID.Zero)
+            {
+                // This should be impossible.  If I've been passed a reference to a client
+                // that client should be registered with the UserService.  So something
+                // is horribly wrong somewhere.
+
+                // m_log.WarnFormat("[XMLRPCGROUPDATA]: Could not find a UserServiceURL for {0}", AgentID);
+
+            }
+        }
+        
     }
 }
 
diff --git a/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs b/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs
index c653e98..672109b 100644
--- a/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs
+++ b/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs
@@ -146,6 +146,7 @@ namespace OpenSim.Region.OptionalModules.Scripting.RegionReady
                 c.Position = new Vector3(((int)Constants.RegionSize * 0.5f), ((int)Constants.RegionSize * 0.5f), 30);
                 c.Sender = null;
                 c.SenderUUID = UUID.Zero;
+                c.Scene = m_scene;
 
                 m_log.InfoFormat("[RegionReady]: Region \"{0}\" is ready: \"{1}\" on channel {2}",
                                  m_scene.RegionInfo.RegionName, c.Message, m_channelNotify);
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
index 3b2c9b1..e4e087f 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
@@ -9784,90 +9784,11 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
                 Notecard nc = new Notecard();
                 nc.lastRef = DateTime.Now;
-                nc.text = ParseText(text.Replace("\r", "").Split('\n'));
+                nc.text = SLUtil.ParseNotecardToList(text).ToArray();
                 m_Notecards[assetID] = nc;
             }
         }
 
-        protected static string[] ParseText(string[] input)
-        {
-            int idx = 0;
-            int level = 0;
-            List<string> output = new List<string>();
-            string[] words;
-
-            while (idx < input.Length)
-            {
-                if (input[idx] == "{")
-                {
-                    level++;
-                    idx++;
-                    continue;
-                }
-
-                if (input[idx]== "}")
-                {
-                    level--;
-                    idx++;
-                    continue;
-                }
-
-                switch (level)
-                {
-                case 0:
-                    words = input[idx].Split(' '); // Linden text ver
-                    // Notecards are created *really* empty. Treat that as "no text" (just like after saving an empty notecard)
-                    if (words.Length < 3)
-                        return new String[0];
-
-                    int version = int.Parse(words[3]);
-                    if (version != 2)
-                        return new String[0];
-                    break;
-                case 1:
-                    words = input[idx].Split(' ');
-                    if (words[0] == "LLEmbeddedItems")
-                        break;
-                    if (words[0] == "Text")
-                    {
-                        int len = int.Parse(words[2]);
-                        idx++;
-
-                        int count = -1;
-
-                        while (count < len)
-                        {
-                            // int l = input[idx].Length;
-                            string ln = input[idx];
-
-                            int need = len-count-1;
-                            if (ln.Length > need)
-                                ln = ln.Substring(0, need);
-
-                            output.Add(ln);
-                            count += ln.Length + 1;
-                            idx++;
-                        }
-
-                        return output.ToArray();
-                    }
-                    break;
-                case 2:
-                    words = input[idx].Split(' '); // count
-                    if (words[0] == "count")
-                    {
-                        int c = int.Parse(words[1]);
-                        if (c > 0)
-                            return new String[0];
-                        break;
-                    }
-                    break;
-                }
-                idx++;
-            }
-            return output.ToArray();
-        }
-
         public static bool IsCached(UUID assetID)
         {
             lock (m_Notecards)
@@ -9923,4 +9844,4 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs b/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs
index d8c0ba5..959164b 100644
--- a/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs
@@ -32,7 +32,7 @@ using System.Globalization;
 using System.Reflection;
 using System.IO;
 using Microsoft.CSharp;
-using Microsoft.JScript;
+//using Microsoft.JScript;
 using Microsoft.VisualBasic;
 using log4net;
 using OpenSim.Region.Framework.Interfaces;
@@ -82,7 +82,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.CodeTools
 
         private static CSharpCodeProvider CScodeProvider = new CSharpCodeProvider();
         private static VBCodeProvider VBcodeProvider = new VBCodeProvider();
-        private static JScriptCodeProvider JScodeProvider = new JScriptCodeProvider();
+//        private static JScriptCodeProvider JScodeProvider = new JScriptCodeProvider();
         private static CSharpCodeProvider YPcodeProvider = new CSharpCodeProvider(); // YP is translated into CSharp
         private static YP2CSConverter YP_Converter = new YP2CSConverter();
 
@@ -395,9 +395,9 @@ namespace OpenSim.Region.ScriptEngine.Shared.CodeTools
                 case enumCompileType.vb:
                     compileScript = CreateVBCompilerScript(compileScript);
                     break;
-                case enumCompileType.js:
-                    compileScript = CreateJSCompilerScript(compileScript);
-                    break;
+//                case enumCompileType.js:
+//                    compileScript = CreateJSCompilerScript(compileScript);
+//                    break;
                 case enumCompileType.yp:
                     compileScript = CreateYPCompilerScript(compileScript);
                     break;
@@ -420,16 +420,16 @@ namespace OpenSim.Region.ScriptEngine.Shared.CodeTools
             }
         }
 
-        private static string CreateJSCompilerScript(string compileScript)
-        {
-            compileScript = String.Empty +
-                "import OpenSim.Region.ScriptEngine.Shared; import System.Collections.Generic;\r\n" +
-                "package SecondLife {\r\n" +
-                "class Script extends OpenSim.Region.ScriptEngine.Shared.ScriptBase.ScriptBaseClass { \r\n" +
-                compileScript +
-                "} }\r\n";
-            return compileScript;
-        }
+//        private static string CreateJSCompilerScript(string compileScript)
+//        {
+//            compileScript = String.Empty +
+//                "import OpenSim.Region.ScriptEngine.Shared; import System.Collections.Generic;\r\n" +
+//                "package SecondLife {\r\n" +
+//                "class Script extends OpenSim.Region.ScriptEngine.Shared.ScriptBase.ScriptBaseClass { \r\n" +
+//                compileScript +
+//                "} }\r\n";
+//            return compileScript;
+//        }
 
         private static string CreateCSCompilerScript(string compileScript)
         {
@@ -580,10 +580,10 @@ namespace OpenSim.Region.ScriptEngine.Shared.CodeTools
                         }
                     } while (!complete);
                     break;
-                case enumCompileType.js:
-                    results = JScodeProvider.CompileAssemblyFromSource(
-                        parameters, Script);
-                    break;
+//                case enumCompileType.js:
+//                    results = JScodeProvider.CompileAssemblyFromSource(
+//                        parameters, Script);
+//                    break;
                 case enumCompileType.yp:
                     results = YPcodeProvider.CompileAssemblyFromSource(
                         parameters, Script);
diff --git a/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs b/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
index d30d2dc..18351ad 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
@@ -541,7 +541,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
                 m_CurrentResult = null;
             }
 
-            return true;
+            return false;
         }
 
         public void SetState(string state)
@@ -991,7 +991,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
         public string GetXMLState()
         {
             bool run = Running;
-            Stop(100);
+            bool stopped = Stop(100);
             Running = run;
 
             // We should not be doing this, but since we are about to
@@ -1002,6 +1002,9 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
 
             // Force an update of the in-memory plugin data
             //
+            if (!stopped)
+                return String.Empty;
+
             PluginData = AsyncCommandManager.GetSerializationData(m_Engine, m_ItemID);
 
             return ScriptSerializer.Serialize(this);
diff --git a/OpenSim/Server/Base/HttpServerBase.cs b/OpenSim/Server/Base/HttpServerBase.cs
index 77184a4..9e4593e 100644
--- a/OpenSim/Server/Base/HttpServerBase.cs
+++ b/OpenSim/Server/Base/HttpServerBase.cs
@@ -71,6 +71,8 @@ namespace OpenSim.Server.Base
                 return m_Servers[port];
 
             m_Servers[port] = new BaseHttpServer(port);
+            
+            m_Log.InfoFormat("[SERVER]: Starting new HTTP server on port {0}", port);
             m_Servers[port].Start();
 
             return m_Servers[port];
@@ -109,6 +111,7 @@ namespace OpenSim.Server.Base
 
         protected override void Initialise()
         {
+            m_Log.InfoFormat("[SERVER]: Starting HTTP server on port {0}", m_HttpServer.Port);
             m_HttpServer.Start();
 
             if (MainConsole.Instance is RemoteConsole)
diff --git a/bin/CSJ2K.dll b/bin/CSJ2K.dll
index 31e0d59..238291f 100644
--- a/bin/CSJ2K.dll
+++ b/bin/CSJ2K.dll
diff --git a/bin/Newtonsoft.Json.XML b/bin/Newtonsoft.Json.XML
index b84e336..5af3593 100644
--- a/bin/Newtonsoft.Json.XML
+++ b/bin/Newtonsoft.Json.XML
@@ -1,990 +1,5827 @@
-<?xml version="1.0"?>
-<doc>
-    <assembly>
-        <name>Newtonsoft.Json</name>
-    </assembly>
-    <members>
-        <member name="M:Newtonsoft.Json.Utilities.StringUtils.ContainsWhiteSpace(System.String)">
-            <summary>
-            Determines whether the string contains white space.
-            </summary>
-            <param name="s">The string to test for white space.</param>
-            <returns>
-                <c>true</c> if the string contains white space; otherwise, <c>false</c>.
-            </returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.StringUtils.IsWhiteSpace(System.String)">
-            <summary>
-            Determines whether the string is all white space. Empty string will return false.
-            </summary>
-            <param name="s">The string to test whether it is all white space.</param>
-            <returns>
-                <c>true</c> if the string is all white space; otherwise, <c>false</c>.
-            </returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.StringUtils.EnsureEndsWith(System.String,System.String)">
-            <summary>
-            Ensures the target string ends with the specified string.
-            </summary>
-            <param name="target">The target.</param>
-            <param name="value">The value.</param>
-            <returns>The target string with the value string at the end.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.StringUtils.IsNullOrEmpty(System.Data.SqlTypes.SqlString)">
-            <summary>
-            Determines whether the SqlString is null or empty.
-            </summary>
-            <param name="s">The string.</param>
-            <returns>
-                <c>true</c> if the SqlString is null or empty; otherwise, <c>false</c>.
-            </returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.StringUtils.IfNotNullOrEmpty(System.String,System.Action{System.String})">
-            <summary>
-            Perform an action if the string is not null or empty.
-            </summary>
-            <param name="value">The value.</param>
-            <param name="action">The action to perform.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.StringUtils.Indent(System.String,System.Int32)">
-            <summary>
-            Indents the specified string.
-            </summary>
-            <param name="s">The string to indent.</param>
-            <param name="indentation">The number of characters to indent by.</param>
-            <returns></returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.StringUtils.Indent(System.String,System.Int32,System.Char)">
-            <summary>
-            Indents the specified string.
-            </summary>
-            <param name="s">The string to indent.</param>
-            <param name="indentation">The number of characters to indent by.</param>
-            <param name="indentChar">The indent character.</param>
-            <returns></returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.StringUtils.NumberLines(System.String)">
-            <summary>
-            Numbers the lines.
-            </summary>
-            <param name="s">The string to number.</param>
-            <returns></returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.StringUtils.NullEmptyString(System.String)">
-            <summary>
-            Nulls an empty string.
-            </summary>
-            <param name="s">The string.</param>
-            <returns>Null if the string was null, otherwise the string unchanged.</returns>
-        </member>
-        <member name="T:Newtonsoft.Json.JsonReaderException">
-            <summary>
-            The exception thrown when an error occurs while reading Json text.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonReaderException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonReaderException"/> class.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonReaderException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonReaderException"/> class
-            with a specified error message.
-            </summary>
-            <param name="message">The error message that explains the reason for the exception.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonReaderException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonReaderException"/> class
-            with a specified error message and a reference to the inner exception that is the cause of this exception.
-            </summary>
-            <param name="message">The error message that explains the reason for the exception.</param>
-            <param name="innerException">The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.GetListItemType(System.Type)">
-            <summary>
-            Gets the type of the typed list's items.
-            </summary>
-            <param name="type">The type.</param>
-            <returns>The type of the typed list's items.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.ItemsUnitializedValue``1(System.Collections.Generic.IList{``0})">
-            <summary>
-            Tests whether the list's items are their unitialized value.
-            </summary>
-            <param name="list">The list.</param>
-            <returns>Whether the list's items are their unitialized value</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.GetMemberUnderlyingType(System.Reflection.MemberInfo)">
-            <summary>
-            Gets the member's underlying type.
-            </summary>
-            <param name="member">The member.</param>
-            <returns>The underlying type of the member.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.IsIndexedProperty(System.Reflection.MemberInfo)">
-            <summary>
-            Determines whether the member is an indexed property.
-            </summary>
-            <param name="member">The member.</param>
-            <returns>
-                <c>true</c> if the member is an indexed property; otherwise, <c>false</c>.
-            </returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.IsIndexedProperty(System.Reflection.PropertyInfo)">
-            <summary>
-            Determines whether the property is an indexed property.
-            </summary>
-            <param name="property">The property.</param>
-            <returns>
-                <c>true</c> if the property is an indexed property; otherwise, <c>false</c>.
-            </returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.GetMemberValue(System.Reflection.MemberInfo,System.Object)">
-            <summary>
-            Gets the member's value on the object.
-            </summary>
-            <param name="member">The member.</param>
-            <param name="target">The target object.</param>
-            <returns>The member's value on the object.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.SetMemberValue(System.Reflection.MemberInfo,System.Object,System.Object)">
-            <summary>
-            Sets the member's value on the target object.
-            </summary>
-            <param name="member">The member.</param>
-            <param name="target">The target.</param>
-            <param name="value">The value.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.CanReadMemberValue(System.Reflection.MemberInfo)">
-            <summary>
-            Determines whether the specified MemberInfo can be read.
-            </summary>
-            <param name="member">The MemberInfo to determine whether can be read.</param>
-            <returns>
-                <c>true</c> if the specified MemberInfo can be read; otherwise, <c>false</c>.
-            </returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.CanSetMemberValue(System.Reflection.MemberInfo)">
-            <summary>
-            Determines whether the specified MemberInfo can be set.
-            </summary>
-            <param name="member">The MemberInfo to determine whether can be set.</param>
-            <returns>
-                <c>true</c> if the specified MemberInfo can be set; otherwise, <c>false</c>.
-            </returns>
-        </member>
-        <member name="T:Newtonsoft.Json.ReferenceLoopHandling">
-            <summary>
-            Specifies reference loop handling options for the <see cref="T:Newtonsoft.Json.JsonWriter"/>.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.ReferenceLoopHandling.Error">
-            <summary>
-            Throw a <see cref="T:Newtonsoft.Json.JsonSerializationException"/> when a loop is encountered.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.ReferenceLoopHandling.Ignore">
-            <summary>
-            Ignore loop references and do not serialize.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.ReferenceLoopHandling.Serialize">
-            <summary>
-            Serialize loop references.
-            </summary>
-        </member>
-        <member name="T:Newtonsoft.Json.JsonSerializer">
-            <summary>
-            Serializes and deserializes objects into and from the Json format.
-            The <see cref="T:Newtonsoft.Json.JsonSerializer"/> enables you to control how objects are encoded into Json.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonSerializer.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonSerializer"/> class.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonSerializer.Deserialize(Newtonsoft.Json.JsonReader)">
-            <summary>
-            Deserializes the Json structure contained by the specified <see cref="T:Newtonsoft.Json.JsonReader"/>.
-            </summary>
-            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> that contains the Json structure to deserialize.</param>
-            <returns>The <see cref="T:System.Object"/> being deserialized.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonSerializer.Deserialize(Newtonsoft.Json.JsonReader,System.Type)">
-            <summary>
-            Deserializes the Json structure contained by the specified <see cref="T:Newtonsoft.Json.JsonReader"/>
-            into an instance of the specified type.
-            </summary>
-            <param name="reader">The type of object to create.</param>
-            <param name="objectType">The <see cref="T:System.Type"/> of object being deserialized.</param>
-            <returns>The instance of <paramref name="objectType"/> being deserialized.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonSerializer.Serialize(System.IO.TextWriter,System.Object)">
-            <summary>
-            Serializes the specified <see cref="T:System.Object"/> and writes the Json structure
-            to a <c>Stream</c> using the specified <see cref="T:System.IO.TextWriter"/>. 
-            </summary>
-            <param name="textWriter">The <see cref="T:System.IO.TextWriter"/> used to write the Json structure.</param>
-            <param name="value">The <see cref="T:System.Object"/> to serialize.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonSerializer.Serialize(Newtonsoft.Json.JsonWriter,System.Object)">
-            <summary>
-            Serializes the specified <see cref="T:System.Object"/> and writes the Json structure
-            to a <c>Stream</c> using the specified <see cref="T:Newtonsoft.Json.JsonWriter"/>. 
-            </summary>
-            <param name="jsonWriter">The <see cref="T:Newtonsoft.Json.JsonWriter"/> used to write the Json structure.</param>
-            <param name="value">The <see cref="T:System.Object"/> to serialize.</param>
-        </member>
-        <member name="P:Newtonsoft.Json.JsonSerializer.ReferenceLoopHandling">
-            <summary>
-            Get or set how reference loops (e.g. a class referencing itself) is handled.
-            </summary>
-        </member>
-        <member name="T:Newtonsoft.Json.JavaScriptArray">
-            <summary>
-            Represents a JavaScript array.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptArray.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JavaScriptObject"/> class.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptArray.#ctor(System.Collections.Generic.IEnumerable{System.Object})">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JavaScriptArray"/> class that
-            contains elements copied from the specified collection.
-            </summary>
-            <param name="collection">The collection whose elements are copied to the new array.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptArray.#ctor(System.Int32)">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JavaScriptArray"/> class that
-            is empty and has the specified initial capacity.
-            </summary>
-            <param name="capacity">The number of elements that the new array can initially store.</param>
-        </member>
-        <member name="T:Newtonsoft.Json.JavaScriptConvert">
-            <summary>
-            Provides methods for converting between common language runtime types and JavaScript types.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JavaScriptConvert.True">
-            <summary>
-            Represents JavaScript's boolean value true as a string. This field is read-only.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JavaScriptConvert.False">
-            <summary>
-            Represents JavaScript's boolean value false as a string. This field is read-only.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JavaScriptConvert.Null">
-            <summary>
-            Represents JavaScript's null as a string. This field is read-only.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JavaScriptConvert.Undefined">
-            <summary>
-            Represents JavaScript's undefined as a string. This field is read-only.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.DateTime)">
-            <summary>
-            Converts the <see cref="T:System.DateTime"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.DateTime"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.Boolean)">
-            <summary>
-            Converts the <see cref="T:System.Boolean"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.Boolean"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.Char)">
-            <summary>
-            Converts the <see cref="T:System.Char"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.Char"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.Enum)">
-            <summary>
-            Converts the <see cref="T:System.Enum"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.Enum"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.Int32)">
-            <summary>
-            Converts the <see cref="T:System.Int32"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.Int32"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.Int16)">
-            <summary>
-            Converts the <see cref="T:System.Int16"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.Int16"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.UInt16)">
-            <summary>
-            Converts the <see cref="T:System.UInt16"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.UInt16"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.UInt32)">
-            <summary>
-            Converts the <see cref="T:System.UInt32"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.UInt32"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.Int64)">
-            <summary>
-            Converts the <see cref="T:System.Int64"/>  to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.Int64"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.UInt64)">
-            <summary>
-            Converts the <see cref="T:System.UInt64"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.UInt64"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.Single)">
-            <summary>
-            Converts the <see cref="T:System.Single"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.Single"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.Double)">
-            <summary>
-            Converts the <see cref="T:System.Double"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.Double"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.Byte)">
-            <summary>
-            Converts the <see cref="T:System.Byte"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.Byte"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.SByte)">
-            <summary>
-            Converts the <see cref="T:System.SByte"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.SByte"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.Decimal)">
-            <summary>
-            Converts the <see cref="T:System.Decimal"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.SByte"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.Guid)">
-            <summary>
-            Converts the <see cref="T:System.Guid"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.Guid"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.String)">
-            <summary>
-            Converts the <see cref="T:System.String"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.String"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.String,System.Char)">
-            <summary>
-            Converts the <see cref="T:System.String"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <param name="delimter">The string delimiter character.</param>
-            <returns>A Json string representation of the <see cref="T:System.String"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.ToString(System.Object)">
-            <summary>
-            Converts the <see cref="T:System.Object"/> to it's JavaScript string representation.
-            </summary>
-            <param name="value">The value to convert.</param>
-            <returns>A Json string representation of the <see cref="T:System.Object"/>.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.SerializeObject(System.Object)">
-            <summary>
-            Serializes the specified object to a Json object.
-            </summary>
-            <param name="value">The object to serialize.</param>
-            <returns>A Json string representation of the object.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.DeserializeObject(System.String)">
-            <summary>
-            Deserializes the specified object to a Json object.
-            </summary>
-            <param name="value">The object to deserialize.</param>
-            <returns>The deserialized object from the Json string.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.DeserializeObject(System.String,System.Type)">
-            <summary>
-            Deserializes the specified object to a Json object.
-            </summary>
-            <param name="value">The object to deserialize.</param>
-            <param name="type">The <see cref="T:System.Type"/> of object being deserialized.</param>
-            <returns>The deserialized object from the Json string.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.DeserializeObject``1(System.String)">
-            <summary>
-            Deserializes the specified object to a Json object.
-            </summary>
-            <typeparam name="T">The type of the object to deserialize.</typeparam>
-            <param name="value">The object to deserialize.</param>
-            <returns>The deserialized object from the Json string.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptConvert.DeserializeObject``1(System.String,Newtonsoft.Json.JsonConverter[])">
-            <summary>
-            Deserializes the specified object to a Json object.
-            </summary>
-            <typeparam name="T">The type of the object to deserialize.</typeparam>
-            <param name="value">The object to deserialize.</param>
-            <param name="converters">Converters to use while deserializing.</param>
-            <returns>The deserialized object from the Json string.</returns>
-        </member>
-        <member name="T:Newtonsoft.Json.JsonSerializationException">
-            <summary>
-            The exception thrown when an error occurs during Json serialization or deserialization.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonSerializationException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonSerializationException"/> class.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonSerializationException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonSerializationException"/> class
-            with a specified error message.
-            </summary>
-            <param name="message">The error message that explains the reason for the exception.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonSerializationException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonSerializationException"/> class
-            with a specified error message and a reference to the inner exception that is the cause of this exception.
-            </summary>
-            <param name="message">The error message that explains the reason for the exception.</param>
-            <param name="innerException">The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified.</param>
-        </member>
-        <member name="T:Newtonsoft.Json.JsonWriterException">
-            <summary>
-            The exception thrown when an error occurs while reading Json text.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriterException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonWriterException"/> class.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriterException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonWriterException"/> class
-            with a specified error message.
-            </summary>
-            <param name="message">The error message that explains the reason for the exception.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriterException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonWriterException"/> class
-            with a specified error message and a reference to the inner exception that is the cause of this exception.
-            </summary>
-            <param name="message">The error message that explains the reason for the exception.</param>
-            <param name="innerException">The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified.</param>
-        </member>
-        <member name="T:Newtonsoft.Json.JavaScriptConstructor">
-            <summary>
-            Represents a JavaScript constructor.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.IsNullOrEmpty(System.Collections.ICollection)">
-            <summary>
-            Determines whether the collection is null or empty.
-            </summary>
-            <param name="collection">The collection.</param>
-            <returns>
-                <c>true</c> if the collection is null or empty; otherwise, <c>false</c>.
-            </returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.IsNullOrEmpty``1(System.Collections.Generic.ICollection{``0})">
-            <summary>
-            Determines whether the collection is null or empty.
-            </summary>
-            <param name="collection">The collection.</param>
-            <returns>
-                <c>true</c> if the collection is null or empty; otherwise, <c>false</c>.
-            </returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.IsNullOrEmptyOrDefault``1(System.Collections.Generic.IList{``0})">
-            <summary>
-            Determines whether the collection is null, empty or its contents are uninitialized values.
-            </summary>
-            <param name="list">The list.</param>
-            <returns>
-                <c>true</c> if the collection is null or empty or its contents are uninitialized values; otherwise, <c>false</c>.
-            </returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.Slice``1(System.Collections.Generic.IList{``0},System.Nullable{System.Int32},System.Nullable{System.Int32})">
-            <summary>
-            Makes a slice of the specified list in between the start and end indexes.
-            </summary>
-            <param name="list">The list.</param>
-            <param name="start">The start index.</param>
-            <param name="end">The end index.</param>
-            <returns>A slice of the list.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.Slice``1(System.Collections.Generic.IList{``0},System.Nullable{System.Int32},System.Nullable{System.Int32},System.Nullable{System.Int32})">
-            <summary>
-            Makes a slice of the specified list in between the start and end indexes,
-            getting every so many items based upon the step.
-            </summary>
-            <param name="list">The list.</param>
-            <param name="start">The start index.</param>
-            <param name="end">The end index.</param>
-            <param name="step">The step.</param>
-            <returns>A slice of the list.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.GroupBy``2(System.Collections.Generic.ICollection{``1},Newtonsoft.Json.Utilities.Func{``1,``0})">
-            <summary>
-            Group the collection using a function which returns the key.
-            </summary>
-            <param name="source">The source collection to group.</param>
-            <param name="keySelector">The key selector.</param>
-            <returns>A Dictionary with each key relating to a list of objects in a list grouped under it.</returns>
-        </member>
-        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.AddRange``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0})">
-            <summary>
-            Adds the elements of the specified collection to the specified generic IList.
-            </summary>
-            <param name="initial">The list to add to.</param>
-            <param name="collection">The collection of elements to add.</param>
-        </member>
-        <member name="T:Newtonsoft.Json.StringBuffer">
-            <summary>
-            Builds a string. Unlike StringBuilder this class lets you reuse it's internal buffer.
-            </summary>
-        </member>
-        <member name="T:Newtonsoft.Json.JavaScriptObject">
-            <summary>
-            Represents a JavaScript object.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptObject.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JavaScriptObject"/> class.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JavaScriptObject.#ctor(Newtonsoft.Json.JavaScriptObject)">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JavaScriptObject"/> class that
-            contains values copied from the specified <see cref="T:Newtonsoft.Json.JavaScriptObject"/>.
-            </summary>
-            <param name="javaScriptObject">The <see cref="T:Newtonsoft.Json.JavaScriptObject"/> whose elements are copied to the new object.</param>
-        </member>
-        <member name="T:Newtonsoft.Json.JsonToken">
-            <summary>
-            Specifies the type of Json token.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.None">
-            <summary>
-            This is returned by the <see cref="T:Newtonsoft.Json.JsonReader"/> if a <see cref="M:Newtonsoft.Json.JsonReader.Read"/> method has not been called. 
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.StartObject">
-            <summary>
-            An object start token.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.StartArray">
-            <summary>
-            An array start token.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.PropertyName">
-            <summary>
-            An object property name.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.Comment">
-            <summary>
-            A comment.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.Integer">
-            <summary>
-            An interger.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.Float">
-            <summary>
-            A float.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.String">
-            <summary>
-            A string.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.Boolean">
-            <summary>
-            A boolean.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.Null">
-            <summary>
-            A null token.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.Undefined">
-            <summary>
-            An undefined token.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.EndObject">
-            <summary>
-            An object end token.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.EndArray">
-            <summary>
-            An array end token.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.Constructor">
-            <summary>
-            A JavaScript object constructor.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.JsonToken.Date">
-            <summary>
-            A Date.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.Converters.XmlNodeConverter.IsNamespaceAttribute(System.String,System.String@)">
-            <summary>
-            Checks if the attributeName is a namespace attribute.
-            </summary>
-            <param name="attributeName">Attribute name to test.</param>
-            <param name="prefix">The attribute name prefix if it has one, otherwise an empty string.</param>
-            <returns>True if attribute name is for a namespace attribute, otherwise false.</returns>
-        </member>
-        <member name="T:Newtonsoft.Json.WriteState">
-            <summary>
-            Specifies the state of the <see cref="T:Newtonsoft.Json.JsonWriter"/>.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.WriteState.Error">
-            <summary>
-            An exception has been thrown, which has left the <see cref="T:Newtonsoft.Json.JsonWriter"/> in an invalid state.
-            You may call the <see cref="M:Newtonsoft.Json.JsonWriter.Close"/> method to put the <see cref="T:Newtonsoft.Json.JsonWriter"/> in the <c>Closed</c> state.
-            Any other <see cref="T:Newtonsoft.Json.JsonWriter"/> method calls results in an <see cref="T:System.InvalidOperationException"/> being thrown. 
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.WriteState.Closed">
-            <summary>
-            The <see cref="M:Newtonsoft.Json.JsonWriter.Close"/> method has been called. 
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.WriteState.Object">
-            <summary>
-            An object is being written. 
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.WriteState.Array">
-            <summary>
-            A array is being written.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.WriteState.Property">
-            <summary>
-            A property is being written.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.WriteState.Start">
-            <summary>
-            A write method has not been called.
-            </summary>
-        </member>
-        <member name="T:Newtonsoft.Json.Formatting">
-            <summary>
-            Specifies formatting options for the <see cref="T:Newtonsoft.Json.JsonWriter"/>.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.Formatting.None">
-            <summary>
-            No special formatting is applied. This is the default.
-            </summary>
-        </member>
-        <member name="F:Newtonsoft.Json.Formatting.Indented">
-            <summary>
-            Causes child objects to be indented according to the <see cref="P:Newtonsoft.Json.JsonWriter.Indentation"/> and <see cref="P:Newtonsoft.Json.JsonWriter.IndentChar"/> settings.
-            </summary>
-        </member>
-        <member name="T:Newtonsoft.Json.JsonWriter">
-            <summary>
-            Represents a writer that provides a fast, non-cached, forward-only way of generating Json data.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.#ctor(System.IO.TextWriter)">
-            <summary>
-            Creates an instance of the <c>JsonWriter</c> class using the specified <see cref="T:System.IO.TextWriter"/>. 
-            </summary>
-            <param name="textWriter">The <c>TextWriter</c> to write to.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.Flush">
-            <summary>
-            Flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.Close">
-            <summary>
-            Closes this stream and the underlying stream.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteStartObject">
-            <summary>
-            Writes the beginning of a Json object.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteEndObject">
-            <summary>
-            Writes the end of a Json object.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteStartArray">
-            <summary>
-            Writes the beginning of a Json array.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteEndArray">
-            <summary>
-            Writes the end of an array.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WritePropertyName(System.String)">
-            <summary>
-            Writes the property name of a name/value pair on a Json object.
-            </summary>
-            <param name="name"></param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteEnd">
-            <summary>
-            Writes the end of the current Json object or array.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteNull">
-            <summary>
-            Writes a null value.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteUndefined">
-            <summary>
-            Writes an undefined value.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteRaw(System.String)">
-            <summary>
-            Writes raw JavaScript manually.
-            </summary>
-            <param name="javaScript">The raw JavaScript to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.String)">
-            <summary>
-            Writes a <see cref="T:System.String"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.String"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Int32)">
-            <summary>
-            Writes a <see cref="T:System.Int32"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.Int32"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.UInt32)">
-            <summary>
-            Writes a <see cref="T:System.UInt32"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.UInt32"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Int64)">
-            <summary>
-            Writes a <see cref="T:System.Int64"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.Int64"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.UInt64)">
-            <summary>
-            Writes a <see cref="T:System.UInt64"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.UInt64"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Single)">
-            <summary>
-            Writes a <see cref="T:System.Single"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.Single"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Double)">
-            <summary>
-            Writes a <see cref="T:System.Double"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.Double"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Boolean)">
-            <summary>
-            Writes a <see cref="T:System.Boolean"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.Boolean"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Int16)">
-            <summary>
-            Writes a <see cref="T:System.Int16"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.Int16"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.UInt16)">
-            <summary>
-            Writes a <see cref="T:System.UInt16"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.UInt16"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Char)">
-            <summary>
-            Writes a <see cref="T:System.Char"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.Char"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Byte)">
-            <summary>
-            Writes a <see cref="T:System.Byte"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.Byte"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.SByte)">
-            <summary>
-            Writes a <see cref="T:System.SByte"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.SByte"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Decimal)">
-            <summary>
-            Writes a <see cref="T:System.Decimal"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.Decimal"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.DateTime)">
-            <summary>
-            Writes a <see cref="T:System.DateTime"/> value.
-            </summary>
-            <param name="value">The <see cref="T:System.DateTime"/> value to write.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteComment(System.String)">
-            <summary>
-            Writes out a comment <code>/*...*/</code> containing the specified text. 
-            </summary>
-            <param name="text">Text to place inside the comment.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonWriter.WriteWhitespace(System.String)">
-            <summary>
-            Writes out the given white space.
-            </summary>
-            <param name="ws">The string of white space characters.</param>
-        </member>
-        <member name="P:Newtonsoft.Json.JsonWriter.WriteState">
-            <summary>
-            Gets the state of the writer.
-            </summary>
-        </member>
-        <member name="P:Newtonsoft.Json.JsonWriter.Formatting">
-            <summary>
-            Indicates how the output is formatted.
-            </summary>
-        </member>
-        <member name="P:Newtonsoft.Json.JsonWriter.Indentation">
-            <summary>
-            Gets or sets how many IndentChars to write for each level in the hierarchy when <paramref name="Formatting"/> is set to <c>Formatting.Indented</c>.
-            </summary>
-        </member>
-        <member name="P:Newtonsoft.Json.JsonWriter.QuoteChar">
-            <summary>
-            Gets or sets which character to use to quote attribute values.
-            </summary>
-        </member>
-        <member name="P:Newtonsoft.Json.JsonWriter.IndentChar">
-            <summary>
-            Gets or sets which character to use for indenting when <paramref name="Formatting"/> is set to <c>Formatting.Indented</c>.
-            </summary>
-        </member>
-        <member name="P:Newtonsoft.Json.JsonWriter.QuoteName">
-            <summary>
-            Gets or sets a value indicating whether object names will be surrounded with quotes.
-            </summary>
-        </member>
-        <member name="T:Newtonsoft.Json.JsonReader">
-            <summary>
-            Represents a reader that provides fast, non-cached, forward-only access to serialized Json data.
-            </summary>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonReader.#ctor(System.IO.TextReader)">
-            <summary>
-            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonReader"/> class with the specified <see cref="T:System.IO.TextReader"/>.
-            </summary>
-            <param name="reader">The <c>TextReader</c> containing the XML data to read.</param>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonReader.Read">
-            <summary>
-            Reads the next Json token from the stream.
-            </summary>
-            <returns></returns>
-        </member>
-        <member name="M:Newtonsoft.Json.JsonReader.Close">
-            <summary>
-            Changes the <see cref="T:Newtonsoft.Json.JsonReader.State"/> to Closed. 
-            </summary>
-        </member>
-        <member name="P:Newtonsoft.Json.JsonReader.QuoteChar">
-            <summary>
-            Gets the quotation mark character used to enclose the value of a string.
-            </summary>
-        </member>
-        <member name="P:Newtonsoft.Json.JsonReader.TokenType">
-            <summary>
-            Gets the type of the current Json token. 
-            </summary>
-        </member>
-        <member name="P:Newtonsoft.Json.JsonReader.Value">
-            <summary>
-            Gets the text value of the current Json token.
-            </summary>
-        </member>
-        <member name="P:Newtonsoft.Json.JsonReader.ValueType">
-            <summary>
-            Gets The Common Language Runtime (CLR) type for the current Json token.
-            </summary>
-        </member>
-    </members>
-</doc>
+<?xml version="1.0"?>

+<doc>

+    <assembly>

+        <name>Newtonsoft.Json.Net20</name>

+    </assembly>

+    <members>

+        <member name="T:Newtonsoft.Json.Bson.BsonReader">

+            <summary>

+            Represents a reader that provides fast, non-cached, forward-only access to serialized Json data.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonReader">

+            <summary>

+            Represents a reader that provides fast, non-cached, forward-only access to serialized Json data.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonReader.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonReader"/> class with the specified <see cref="T:System.IO.TextReader"/>.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonReader.Read">

+            <summary>

+            Reads the next JSON token from the stream.

+            </summary>

+            <returns>true if the next token was read successfully; false if there are no more tokens to read.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonReader.ReadAsBytes">

+            <summary>

+            Reads the next JSON token from the stream as a <see cref="T:Byte[]"/>.

+            </summary>

+            <returns>A <see cref="T:Byte[]"/> or a null reference if the next JSON token is null.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonReader.Skip">

+            <summary>

+            Skips the children of the current token.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonReader.SetToken(Newtonsoft.Json.JsonToken)">

+            <summary>

+            Sets the current token.

+            </summary>

+            <param name="newToken">The new token.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonReader.SetToken(Newtonsoft.Json.JsonToken,System.Object)">

+            <summary>

+            Sets the current token and value.

+            </summary>

+            <param name="newToken">The new token.</param>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonReader.SetStateBasedOnCurrent">

+            <summary>

+            Sets the state based on current token type.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonReader.System#IDisposable#Dispose">

+            <summary>

+            Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonReader.Dispose(System.Boolean)">

+            <summary>

+            Releases unmanaged and - optionally - managed resources

+            </summary>

+            <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonReader.Close">

+            <summary>

+            Changes the <see cref="T:Newtonsoft.Json.JsonReader.State"/> to Closed. 

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonReader.CurrentState">

+            <summary>

+            Gets the current reader state.

+            </summary>

+            <value>The current reader state.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonReader.QuoteChar">

+            <summary>

+            Gets the quotation mark character used to enclose the value of a string.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonReader.TokenType">

+            <summary>

+            Gets the type of the current Json token. 

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonReader.Value">

+            <summary>

+            Gets the text value of the current Json token.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonReader.ValueType">

+            <summary>

+            Gets The Common Language Runtime (CLR) type for the current Json token.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonReader.Depth">

+            <summary>

+            Gets the depth of the current token in the JSON document.

+            </summary>

+            <value>The depth of the current token in the JSON document.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonReader.State">

+            <summary>

+            Specifies the state of the reader.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonReader.State.Start">

+            <summary>

+            The Read method has not been called.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonReader.State.Complete">

+            <summary>

+            The end of the file has been reached successfully.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonReader.State.Property">

+            <summary>

+            Reader is at a property.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonReader.State.ObjectStart">

+            <summary>

+            Reader is at the start of an object.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonReader.State.Object">

+            <summary>

+            Reader is in an object.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonReader.State.ArrayStart">

+            <summary>

+            Reader is at the start of an array.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonReader.State.Array">

+            <summary>

+            Reader is in an array.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonReader.State.Closed">

+            <summary>

+            The Close method has been called.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonReader.State.PostValue">

+            <summary>

+            Reader has just read a value.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonReader.State.ConstructorStart">

+            <summary>

+            Reader is at the start of a constructor.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonReader.State.Constructor">

+            <summary>

+            Reader in a constructor.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonReader.State.Error">

+            <summary>

+            An error occurred that prevents the read operation from continuing.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonReader.State.Finished">

+            <summary>

+            The end of the file has been reached successfully.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Bson.BsonReader.#ctor(System.IO.Stream)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Bson.BsonReader"/> class.

+            </summary>

+            <param name="stream">The stream.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Bson.BsonReader.#ctor(System.IO.Stream,System.Boolean,System.DateTimeKind)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Bson.BsonReader"/> class.

+            </summary>

+            <param name="stream">The stream.</param>

+            <param name="readRootValueAsArray">if set to <c>true</c> the root object will be read as a JSON array.</param>

+            <param name="dateTimeKindHandling">The <see cref="T:System.DateTimeKind"/> used when reading <see cref="T:System.DateTime"/> values from BSON.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Bson.BsonReader.ReadAsBytes">

+            <summary>

+            Reads the next JSON token from the stream as a <see cref="T:Byte[]"/>.

+            </summary>

+            <returns>

+            A <see cref="T:Byte[]"/> or a null reference if the next JSON token is null.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Bson.BsonReader.Read">

+            <summary>

+            Reads the next JSON token from the stream.

+            </summary>

+            <returns>

+            true if the next token was read successfully; false if there are no more tokens to read.

+            </returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Bson.BsonReader.ReadRootValueAsArray">

+            <summary>

+            Gets or sets a value indicating whether the root object will be read as a JSON array.

+            </summary>

+            <value>

+                <c>true</c> if the root object will be read as a JSON array; otherwise, <c>false</c>.

+            </value>

+        </member>

+        <member name="P:Newtonsoft.Json.Bson.BsonReader.DateTimeKindHandling">

+            <summary>

+            Gets or sets the <see cref="T:System.DateTimeKind"/> used when reading <see cref="T:System.DateTime"/> values from BSON.

+            </summary>

+            <value>The <see cref="T:System.DateTimeKind"/> used when reading <see cref="T:System.DateTime"/> values from BSON.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Bson.BsonWriter">

+            <summary>

+            Represents a writer that provides a fast, non-cached, forward-only way of generating Json data.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.JTokenWriter">

+            <summary>

+            Represents a writer that provides a fast, non-cached, forward-only way of generating Json data.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonWriter">

+            <summary>

+            Represents a writer that provides a fast, non-cached, forward-only way of generating Json data.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.#ctor">

+            <summary>

+            Creates an instance of the <c>JsonWriter</c> class. 

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.Flush">

+            <summary>

+            Flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.Close">

+            <summary>

+            Closes this stream and the underlying stream.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteStartObject">

+            <summary>

+            Writes the beginning of a Json object.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteEndObject">

+            <summary>

+            Writes the end of a Json object.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteStartArray">

+            <summary>

+            Writes the beginning of a Json array.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteEndArray">

+            <summary>

+            Writes the end of an array.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteStartConstructor(System.String)">

+            <summary>

+            Writes the start of a constructor with the given name.

+            </summary>

+            <param name="name">The name of the constructor.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteEndConstructor">

+            <summary>

+            Writes the end constructor.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WritePropertyName(System.String)">

+            <summary>

+            Writes the property name of a name/value pair on a Json object.

+            </summary>

+            <param name="name">The name of the property.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteEnd">

+            <summary>

+            Writes the end of the current Json object or array.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteToken(Newtonsoft.Json.JsonReader)">

+            <summary>

+            Writes the current <see cref="T:Newtonsoft.Json.JsonReader"/> token.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read the token from.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteEnd(Newtonsoft.Json.JsonToken)">

+            <summary>

+            Writes the specified end token.

+            </summary>

+            <param name="token">The end token to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteIndent">

+            <summary>

+            Writes indent characters.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValueDelimiter">

+            <summary>

+            Writes the JSON value delimiter.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteIndentSpace">

+            <summary>

+            Writes an indent space.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteNull">

+            <summary>

+            Writes a null value.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteUndefined">

+            <summary>

+            Writes an undefined value.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteRaw(System.String)">

+            <summary>

+            Writes raw JSON without changing the writer's state.

+            </summary>

+            <param name="json">The raw JSON to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteRawValue(System.String)">

+            <summary>

+            Writes raw JSON where a value is expected and updates the writer's state.

+            </summary>

+            <param name="json">The raw JSON to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.String)">

+            <summary>

+            Writes a <see cref="T:System.String"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.String"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Int32)">

+            <summary>

+            Writes a <see cref="T:System.Int32"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Int32"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.UInt32)">

+            <summary>

+            Writes a <see cref="T:System.UInt32"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.UInt32"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Int64)">

+            <summary>

+            Writes a <see cref="T:System.Int64"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Int64"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.UInt64)">

+            <summary>

+            Writes a <see cref="T:System.UInt64"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.UInt64"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Single)">

+            <summary>

+            Writes a <see cref="T:System.Single"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Single"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Double)">

+            <summary>

+            Writes a <see cref="T:System.Double"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Double"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Boolean)">

+            <summary>

+            Writes a <see cref="T:System.Boolean"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Boolean"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Int16)">

+            <summary>

+            Writes a <see cref="T:System.Int16"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Int16"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.UInt16)">

+            <summary>

+            Writes a <see cref="T:System.UInt16"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.UInt16"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Char)">

+            <summary>

+            Writes a <see cref="T:System.Char"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Char"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Byte)">

+            <summary>

+            Writes a <see cref="T:System.Byte"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Byte"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.SByte)">

+            <summary>

+            Writes a <see cref="T:System.SByte"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.SByte"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Decimal)">

+            <summary>

+            Writes a <see cref="T:System.Decimal"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Decimal"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.DateTime)">

+            <summary>

+            Writes a <see cref="T:System.DateTime"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.DateTime"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.Int32})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.UInt32})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.Int64})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.UInt64})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.Single})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.Double})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.Boolean})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.Int16})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.UInt16})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.Char})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.Byte})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.SByte})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.Decimal})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Nullable{System.DateTime})">

+            <summary>

+            Writes a <see cref="T:System.Nullable`1"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Nullable`1"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Byte[])">

+            <summary>

+            Writes a <see cref="T:Byte[]"/> value.

+            </summary>

+            <param name="value">The <see cref="T:Byte[]"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteValue(System.Object)">

+            <summary>

+            Writes a <see cref="T:System.Object"/> value.

+            An error will raised if the value cannot be written as a single JSON token.

+            </summary>

+            <param name="value">The <see cref="T:System.Object"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteComment(System.String)">

+            <summary>

+            Writes out a comment <code>/*...*/</code> containing the specified text. 

+            </summary>

+            <param name="text">Text to place inside the comment.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriter.WriteWhitespace(System.String)">

+            <summary>

+            Writes out the given white space.

+            </summary>

+            <param name="ws">The string of white space characters.</param>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonWriter.Top">

+            <summary>

+            Gets the top.

+            </summary>

+            <value>The top.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonWriter.WriteState">

+            <summary>

+            Gets the state of the writer.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonWriter.Formatting">

+            <summary>

+            Indicates how the output is formatted.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.#ctor(Newtonsoft.Json.Linq.JContainer)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JTokenWriter"/> class writing to the given <see cref="T:Newtonsoft.Json.Linq.JContainer"/>.

+            </summary>

+            <param name="container">The container being written to.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JTokenWriter"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.Flush">

+            <summary>

+            Flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.Close">

+            <summary>

+            Closes this stream and the underlying stream.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteStartObject">

+            <summary>

+            Writes the beginning of a Json object.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteStartArray">

+            <summary>

+            Writes the beginning of a Json array.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteStartConstructor(System.String)">

+            <summary>

+            Writes the start of a constructor with the given name.

+            </summary>

+            <param name="name">The name of the constructor.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteEnd(Newtonsoft.Json.JsonToken)">

+            <summary>

+            Writes the end.

+            </summary>

+            <param name="token">The token.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WritePropertyName(System.String)">

+            <summary>

+            Writes the property name of a name/value pair on a Json object.

+            </summary>

+            <param name="name">The name of the property.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteNull">

+            <summary>

+            Writes a null value.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteUndefined">

+            <summary>

+            Writes an undefined value.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteRaw(System.String)">

+            <summary>

+            Writes raw JSON.

+            </summary>

+            <param name="json">The raw JSON to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteComment(System.String)">

+            <summary>

+            Writes out a comment <code>/*...*/</code> containing the specified text.

+            </summary>

+            <param name="text">Text to place inside the comment.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.String)">

+            <summary>

+            Writes a <see cref="T:System.String"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.String"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.Int32)">

+            <summary>

+            Writes a <see cref="T:System.Int32"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Int32"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.UInt32)">

+            <summary>

+            Writes a <see cref="T:System.UInt32"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.UInt32"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.Int64)">

+            <summary>

+            Writes a <see cref="T:System.Int64"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Int64"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.UInt64)">

+            <summary>

+            Writes a <see cref="T:System.UInt64"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.UInt64"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.Single)">

+            <summary>

+            Writes a <see cref="T:System.Single"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Single"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.Double)">

+            <summary>

+            Writes a <see cref="T:System.Double"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Double"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.Boolean)">

+            <summary>

+            Writes a <see cref="T:System.Boolean"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Boolean"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.Int16)">

+            <summary>

+            Writes a <see cref="T:System.Int16"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Int16"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.UInt16)">

+            <summary>

+            Writes a <see cref="T:System.UInt16"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.UInt16"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.Char)">

+            <summary>

+            Writes a <see cref="T:System.Char"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Char"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.Byte)">

+            <summary>

+            Writes a <see cref="T:System.Byte"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Byte"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.SByte)">

+            <summary>

+            Writes a <see cref="T:System.SByte"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.SByte"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.Decimal)">

+            <summary>

+            Writes a <see cref="T:System.Decimal"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Decimal"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.DateTime)">

+            <summary>

+            Writes a <see cref="T:System.DateTime"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.DateTime"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenWriter.WriteValue(System.Byte[])">

+            <summary>

+            Writes a <see cref="T:Byte[]"/> value.

+            </summary>

+            <param name="value">The <see cref="T:Byte[]"/> value to write.</param>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JTokenWriter.Token">

+            <summary>

+            Gets the token being writen.

+            </summary>

+            <value>The token being writen.</value>

+        </member>

+        <member name="M:Newtonsoft.Json.Bson.BsonWriter.#ctor(System.IO.Stream)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Bson.BsonWriter"/> class.

+            </summary>

+            <param name="stream">The stream.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Bson.BsonWriter.Flush">

+            <summary>

+            Flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Bson.BsonWriter.WriteEnd(Newtonsoft.Json.JsonToken)">

+            <summary>

+            Writes the end.

+            </summary>

+            <param name="token">The token.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Bson.BsonWriter.WriteComment(System.String)">

+            <summary>

+            Writes out a comment <code>/*...*/</code> containing the specified text.

+            </summary>

+            <param name="text">Text to place inside the comment.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Bson.BsonWriter.WriteStartConstructor(System.String)">

+            <summary>

+            Writes the start of a constructor with the given name.

+            </summary>

+            <param name="name">The name of the constructor.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Bson.BsonWriter.WriteRaw(System.String)">

+            <summary>

+            Writes raw JSON.

+            </summary>

+            <param name="json">The raw JSON to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Bson.BsonWriter.WriteRawValue(System.String)">

+            <summary>

+            Writes raw JSON where a value is expected and updates the writer's state.

+            </summary>

+            <param name="json">The raw JSON to write.</param>

+        </member>

+        <member name="T:Newtonsoft.Json.ConstructorHandling">

+            <summary>

+            Specifies how constructors are used when initializing objects during deserialization by the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.ConstructorHandling.Default">

+            <summary>

+            First attempt to use the public default constructor then fall back to single paramatized constructor.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.ConstructorHandling.AllowNonPublicDefaultConstructor">

+            <summary>

+            Allow Json.NET to use a non-public default constructor.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Converters.BinaryConverter">

+            <summary>

+            Converts a binary value to and from a base 64 string value.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonConverter">

+            <summary>

+            Converts an object to and from JSON.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConverter.WriteJson(Newtonsoft.Json.JsonWriter,System.Object,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Writes the JSON representation of the object.

+            </summary>

+            <param name="writer">The <see cref="T:Newtonsoft.Json.JsonWriter"/> to write to.</param>

+            <param name="value">The value.</param>

+            <param name="serializer">The calling serializer.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConverter.ReadJson(Newtonsoft.Json.JsonReader,System.Type,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Reads the JSON representation of the object.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read from.</param>

+            <param name="objectType">Type of the object.</param>

+            <param name="serializer">The calling serializer.</param>

+            <returns>The object value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConverter.CanConvert(System.Type)">

+            <summary>

+            Determines whether this instance can convert the specified object type.

+            </summary>

+            <param name="objectType">Type of the object.</param>

+            <returns>

+                <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.BinaryConverter.WriteJson(Newtonsoft.Json.JsonWriter,System.Object,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Writes the JSON representation of the object.

+            </summary>

+            <param name="writer">The <see cref="T:Newtonsoft.Json.JsonWriter"/> to write to.</param>

+            <param name="value">The value.</param>

+            <param name="serializer">The calling serializer.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.BinaryConverter.ReadJson(Newtonsoft.Json.JsonReader,System.Type,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Reads the JSON representation of the object.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read from.</param>

+            <param name="objectType">Type of the object.</param>

+            <param name="serializer">The calling serializer.</param>

+            <returns>The object value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.BinaryConverter.CanConvert(System.Type)">

+            <summary>

+            Determines whether this instance can convert the specified object type.

+            </summary>

+            <param name="objectType">Type of the object.</param>

+            <returns>

+                <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Converters.CustomCreationConverter`1">

+            <summary>

+            Create a custom object

+            </summary>

+            <typeparam name="T"></typeparam>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.CustomCreationConverter`1.WriteJson(Newtonsoft.Json.JsonWriter,System.Object,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Writes the JSON representation of the object.

+            </summary>

+            <param name="writer">The <see cref="T:Newtonsoft.Json.JsonWriter"/> to write to.</param>

+            <param name="value">The value.</param>

+            <param name="serializer">The calling serializer.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.CustomCreationConverter`1.ReadJson(Newtonsoft.Json.JsonReader,System.Type,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Reads the JSON representation of the object.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read from.</param>

+            <param name="objectType">Type of the object.</param>

+            <param name="serializer">The calling serializer.</param>

+            <returns>The object value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.CustomCreationConverter`1.Create(System.Type)">

+            <summary>

+            Creates an object which will then be populated by the serializer.

+            </summary>

+            <param name="objectType">Type of the object.</param>

+            <returns></returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.CustomCreationConverter`1.CanConvert(System.Type)">

+            <summary>

+            Determines whether this instance can convert the specified object type.

+            </summary>

+            <param name="objectType">Type of the object.</param>

+            <returns>

+                <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Converters.DataSetConverter">

+            <summary>

+            Converts a <see cref="T:System.Data.DataSet"/> to and from JSON.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.DataSetConverter.WriteJson(Newtonsoft.Json.JsonWriter,System.Object,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Writes the JSON representation of the object.

+            </summary>

+            <param name="writer">The <see cref="T:Newtonsoft.Json.JsonWriter"/> to write to.</param>

+            <param name="value">The value.</param>

+            <param name="serializer">The calling serializer.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.DataSetConverter.ReadJson(Newtonsoft.Json.JsonReader,System.Type,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Reads the JSON representation of the object.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read from.</param>

+            <param name="objectType">Type of the object.</param>

+            <param name="serializer">The calling serializer.</param>

+            <returns>The object value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.DataSetConverter.CanConvert(System.Type)">

+            <summary>

+            Determines whether this instance can convert the specified value type.

+            </summary>

+            <param name="valueType">Type of the value.</param>

+            <returns>

+                <c>true</c> if this instance can convert the specified value type; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Converters.DataTableConverter">

+            <summary>

+            Converts a <see cref="T:System.Data.DataTable"/> to and from JSON.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.DataTableConverter.WriteJson(Newtonsoft.Json.JsonWriter,System.Object,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Writes the JSON representation of the object.

+            </summary>

+            <param name="writer">The <see cref="T:Newtonsoft.Json.JsonWriter"/> to write to.</param>

+            <param name="value">The value.</param>

+            <param name="serializer">The calling serializer.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.DataTableConverter.ReadJson(Newtonsoft.Json.JsonReader,System.Type,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Reads the JSON representation of the object.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read from.</param>

+            <param name="objectType">Type of the object.</param>

+            <param name="serializer">The calling serializer.</param>

+            <returns>The object value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.DataTableConverter.CanConvert(System.Type)">

+            <summary>

+            Determines whether this instance can convert the specified value type.

+            </summary>

+            <param name="valueType">Type of the value.</param>

+            <returns>

+                <c>true</c> if this instance can convert the specified value type; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Converters.DateTimeConverterBase">

+            <summary>

+            Provides a base class for converting a <see cref="T:System.DateTime"/> to and from JSON.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.DateTimeConverterBase.CanConvert(System.Type)">

+            <summary>

+            Determines whether this instance can convert the specified object type.

+            </summary>

+            <param name="objectType">Type of the object.</param>

+            <returns>

+                <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Converters.StringEnumConverter">

+            <summary>

+            Converts an <see cref="T:System.Enum"/> to and from its name string value.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.StringEnumConverter.WriteJson(Newtonsoft.Json.JsonWriter,System.Object,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Writes the JSON representation of the object.

+            </summary>

+            <param name="writer">The <see cref="T:Newtonsoft.Json.JsonWriter"/> to write to.</param>

+            <param name="value">The value.</param>

+            <param name="serializer">The calling serializer.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.StringEnumConverter.ReadJson(Newtonsoft.Json.JsonReader,System.Type,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Reads the JSON representation of the object.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read from.</param>

+            <param name="objectType">Type of the object.</param>

+            <param name="serializer">The calling serializer.</param>

+            <returns>The object value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.StringEnumConverter.CanConvert(System.Type)">

+            <summary>

+            Determines whether this instance can convert the specified object type.

+            </summary>

+            <param name="objectType">Type of the object.</param>

+            <returns>

+                <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.ComponentModel.JPropertyDescriptor">

+            <summary>

+            Represents a view of a <see cref="T:Newtonsoft.Json.Linq.JProperty"/>.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JPropertyDescriptor.#ctor(System.String,System.Type)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.ComponentModel.JPropertyDescriptor"/> class.

+            </summary>

+            <param name="name">The name.</param>

+            <param name="propertyType">Type of the property.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JPropertyDescriptor.CanResetValue(System.Object)">

+            <summary>

+            When overridden in a derived class, returns whether resetting an object changes its value.

+            </summary>

+            <returns>

+            true if resetting the component changes its value; otherwise, false.

+            </returns>

+            <param name="component">The component to test for reset capability. 

+                            </param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JPropertyDescriptor.GetValue(System.Object)">

+            <summary>

+            When overridden in a derived class, gets the current value of the property on a component.

+            </summary>

+            <returns>

+            The value of a property for a given component.

+            </returns>

+            <param name="component">The component with the property for which to retrieve the value. 

+                            </param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JPropertyDescriptor.ResetValue(System.Object)">

+            <summary>

+            When overridden in a derived class, resets the value for this property of the component to the default value.

+            </summary>

+            <param name="component">The component with the property value that is to be reset to the default value. 

+                            </param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JPropertyDescriptor.SetValue(System.Object,System.Object)">

+            <summary>

+            When overridden in a derived class, sets the value of the component to a different value.

+            </summary>

+            <param name="component">The component with the property value that is to be set. 

+                            </param><param name="value">The new value. 

+                            </param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JPropertyDescriptor.ShouldSerializeValue(System.Object)">

+            <summary>

+            When overridden in a derived class, determines a value indicating whether the value of this property needs to be persisted.

+            </summary>

+            <returns>

+            true if the property should be persisted; otherwise, false.

+            </returns>

+            <param name="component">The component with the property to be examined for persistence. 

+                            </param>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.ComponentModel.JPropertyDescriptor.ComponentType">

+            <summary>

+            When overridden in a derived class, gets the type of the component this property is bound to.

+            </summary>

+            <returns>

+            A <see cref="T:System.Type"/> that represents the type of component this property is bound to. When the <see cref="M:System.ComponentModel.PropertyDescriptor.GetValue(System.Object)"/> or <see cref="M:System.ComponentModel.PropertyDescriptor.SetValue(System.Object,System.Object)"/> methods are invoked, the object specified might be an instance of this type.

+            </returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.ComponentModel.JPropertyDescriptor.IsReadOnly">

+            <summary>

+            When overridden in a derived class, gets a value indicating whether this property is read-only.

+            </summary>

+            <returns>

+            true if the property is read-only; otherwise, false.

+            </returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.ComponentModel.JPropertyDescriptor.PropertyType">

+            <summary>

+            When overridden in a derived class, gets the type of the property.

+            </summary>

+            <returns>

+            A <see cref="T:System.Type"/> that represents the type of the property.

+            </returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.ComponentModel.JPropertyDescriptor.NameHashCode">

+            <summary>

+            Gets the hash code for the name of the member.

+            </summary>

+            <value></value>

+            <returns>

+            The hash code for the name of the member.

+            </returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor">

+            <summary>

+            Represents a view of a <see cref="T:Newtonsoft.Json.Linq.JObject"/>.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor.#ctor(Newtonsoft.Json.Linq.JObject)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor"/> class.

+            </summary>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor.GetProperties">

+            <summary>

+            Returns the properties for this instance of a component.

+            </summary>

+            <returns>

+            A <see cref="T:System.ComponentModel.PropertyDescriptorCollection"/> that represents the properties for this component instance.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor.GetProperties(System.Attribute[])">

+            <summary>

+            Returns the properties for this instance of a component using the attribute array as a filter.

+            </summary>

+            <param name="attributes">An array of type <see cref="T:System.Attribute"/> that is used as a filter.</param>

+            <returns>

+            A <see cref="T:System.ComponentModel.PropertyDescriptorCollection"/> that represents the filtered properties for this component instance.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor.GetAttributes">

+            <summary>

+            Returns a collection of custom attributes for this instance of a component.

+            </summary>

+            <returns>

+            An <see cref="T:System.ComponentModel.AttributeCollection"/> containing the attributes for this object.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor.GetClassName">

+            <summary>

+            Returns the class name of this instance of a component.

+            </summary>

+            <returns>

+            The class name of the object, or null if the class does not have a name.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor.GetComponentName">

+            <summary>

+            Returns the name of this instance of a component.

+            </summary>

+            <returns>

+            The name of the object, or null if the object does not have a name.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor.GetConverter">

+            <summary>

+            Returns a type converter for this instance of a component.

+            </summary>

+            <returns>

+            A <see cref="T:System.ComponentModel.TypeConverter"/> that is the converter for this object, or null if there is no <see cref="T:System.ComponentModel.TypeConverter"/> for this object.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor.GetDefaultEvent">

+            <summary>

+            Returns the default event for this instance of a component.

+            </summary>

+            <returns>

+            An <see cref="T:System.ComponentModel.EventDescriptor"/> that represents the default event for this object, or null if this object does not have events.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor.GetDefaultProperty">

+            <summary>

+            Returns the default property for this instance of a component.

+            </summary>

+            <returns>

+            A <see cref="T:System.ComponentModel.PropertyDescriptor"/> that represents the default property for this object, or null if this object does not have properties.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor.GetEditor(System.Type)">

+            <summary>

+            Returns an editor of the specified type for this instance of a component.

+            </summary>

+            <param name="editorBaseType">A <see cref="T:System.Type"/> that represents the editor for this object.</param>

+            <returns>

+            An <see cref="T:System.Object"/> of the specified type that is the editor for this object, or null if the editor cannot be found.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor.GetEvents(System.Attribute[])">

+            <summary>

+            Returns the events for this instance of a component using the specified attribute array as a filter.

+            </summary>

+            <param name="attributes">An array of type <see cref="T:System.Attribute"/> that is used as a filter.</param>

+            <returns>

+            An <see cref="T:System.ComponentModel.EventDescriptorCollection"/> that represents the filtered events for this component instance.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor.GetEvents">

+            <summary>

+            Returns the events for this instance of a component.

+            </summary>

+            <returns>

+            An <see cref="T:System.ComponentModel.EventDescriptorCollection"/> that represents the events for this component instance.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.ComponentModel.JTypeDescriptor.GetPropertyOwner(System.ComponentModel.PropertyDescriptor)">

+            <summary>

+            Returns an object that contains the property described by the specified property descriptor.

+            </summary>

+            <param name="pd">A <see cref="T:System.ComponentModel.PropertyDescriptor"/> that represents the property whose owner is to be found.</param>

+            <returns>

+            An <see cref="T:System.Object"/> that represents the owner of the specified property.

+            </returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.JRaw">

+            <summary>

+            Represents a raw JSON string.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.JValue">

+            <summary>

+            Represents a value in JSON (string, integer, date, etc).

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Represents an abstract JSON token.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.IJEnumerable`1">

+            <summary>

+            Represents a collection of <see cref="T:Newtonsoft.Json.Linq.JToken"/> objects.

+            </summary>

+            <typeparam name="T">The type of token</typeparam>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.IJEnumerable`1.Item(System.Object)">

+            <summary>

+            Gets the <see cref="T:Newtonsoft.Json.Linq.IJEnumerable`1"/> with the specified key.

+            </summary>

+            <value></value>

+        </member>

+        <member name="T:Newtonsoft.Json.IJsonLineInfo">

+            <summary>

+            Provides an interface to enable a class to return line and position information.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.IJsonLineInfo.HasLineInfo">

+            <summary>

+            Gets a value indicating whether the class can return line information.

+            </summary>

+            <returns>

+                <c>true</c> if LineNumber and LinePosition can be provided; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="P:Newtonsoft.Json.IJsonLineInfo.LineNumber">

+            <summary>

+            Gets the current line number.

+            </summary>

+            <value>The current line number or 0 if no line information is available (for example, HasLineInfo returns false).</value>

+        </member>

+        <member name="P:Newtonsoft.Json.IJsonLineInfo.LinePosition">

+            <summary>

+            Gets the current line position.

+            </summary>

+            <value>The current line position or 0 if no line information is available (for example, HasLineInfo returns false).</value>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.DeepEquals(Newtonsoft.Json.Linq.JToken,Newtonsoft.Json.Linq.JToken)">

+            <summary>

+            Compares the values of two tokens, including the values of all descendant tokens.

+            </summary>

+            <param name="t1">The first <see cref="T:Newtonsoft.Json.Linq.JToken"/> to compare.</param>

+            <param name="t2">The second <see cref="T:Newtonsoft.Json.Linq.JToken"/> to compare.</param>

+            <returns>true if the tokens are equal; otherwise false.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.AddAfterSelf(System.Object)">

+            <summary>

+            Adds the specified content immediately after this token.

+            </summary>

+            <param name="content">A content object that contains simple content or a collection of content objects to be added after this token.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.AddBeforeSelf(System.Object)">

+            <summary>

+            Adds the specified content immediately before this token.

+            </summary>

+            <param name="content">A content object that contains simple content or a collection of content objects to be added before this token.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.Ancestors">

+            <summary>

+            Returns a collection of the ancestor tokens of this token.

+            </summary>

+            <returns>A collection of the ancestor tokens of this token.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.AfterSelf">

+            <summary>

+            Returns a collection of the sibling tokens after this token, in document order.

+            </summary>

+            <returns>A collection of the sibling tokens after this tokens, in document order.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.BeforeSelf">

+            <summary>

+            Returns a collection of the sibling tokens before this token, in document order.

+            </summary>

+            <returns>A collection of the sibling tokens before this token, in document order.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.Value``1(System.Object)">

+            <summary>

+            Gets the <see cref="T:Newtonsoft.Json.Linq.JToken"/> with the specified key converted to the specified type.

+            </summary>

+            <typeparam name="T">The type to convert the token to.</typeparam>

+            <param name="key">The token key.</param>

+            <returns>The converted token value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.Children">

+            <summary>

+            Returns a collection of the child tokens of this token, in document order.

+            </summary>

+            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> containing the child tokens of this <see cref="T:Newtonsoft.Json.Linq.JToken"/>, in document order.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.Children``1">

+            <summary>

+            Returns a collection of the child tokens of this token, in document order, filtered by the specified type.

+            </summary>

+            <typeparam name="T">The type to filter the child tokens on.</typeparam>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JEnumerable`1"/> containing the child tokens of this <see cref="T:Newtonsoft.Json.Linq.JToken"/>, in document order.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.Values``1">

+            <summary>

+            Returns a collection of the child values of this token, in document order.

+            </summary>

+            <typeparam name="T">The type to convert the values to.</typeparam>

+            <returns>A <see cref="T:System.Collections.Generic.IEnumerable`1"/> containing the child values of this <see cref="T:Newtonsoft.Json.Linq.JToken"/>, in document order.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.Remove">

+            <summary>

+            Removes this token from its parent.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.Replace(Newtonsoft.Json.Linq.JToken)">

+            <summary>

+            Replaces this token with the specified token.

+            </summary>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.WriteTo(Newtonsoft.Json.JsonWriter,Newtonsoft.Json.JsonConverter[])">

+            <summary>

+            Writes this token to a <see cref="T:Newtonsoft.Json.JsonWriter"/>.

+            </summary>

+            <param name="writer">A <see cref="T:Newtonsoft.Json.JsonWriter"/> into which this method will write.</param>

+            <param name="converters">A collection of <see cref="T:Newtonsoft.Json.JsonConverter"/> which will be used when writing the token.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.ToString">

+            <summary>

+            Returns the indented JSON for this token.

+            </summary>

+            <returns>

+            The indented JSON for this token.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.ToString(Newtonsoft.Json.Formatting,Newtonsoft.Json.JsonConverter[])">

+            <summary>

+            Returns the JSON for this token using the given formatting and converters.

+            </summary>

+            <param name="formatting">Indicates how the output is formatted.</param>

+            <param name="converters">A collection of <see cref="T:Newtonsoft.Json.JsonConverter"/> which will be used when writing the token.</param>

+            <returns>The JSON for this token using the given formatting and converters.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Boolean">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Boolean"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Nullable{System.Boolean}">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Nullable`1"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Int64">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Int64"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Nullable{System.DateTime}">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Nullable`1"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Nullable{System.Decimal}">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Nullable`1"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Nullable{System.Double}">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Nullable`1"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Int32">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Int32"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Nullable{System.Int32}">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Nullable`1"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.DateTime">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.DateTime"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Nullable{System.Int64}">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Nullable`1"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Nullable{System.Single}">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Nullable`1"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Decimal">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Decimal"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Nullable{System.UInt32}">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Nullable`1"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Nullable{System.UInt64}">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Nullable`1"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Double">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Double"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Single">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Single"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.String">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.String"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.UInt32">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.UInt32"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.UInt64">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.UInt64"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Explicit(Newtonsoft.Json.Linq.JToken)~System.Byte[]">

+            <summary>

+            Performs an explicit conversion from <see cref="T:Newtonsoft.Json.Linq.JToken"/> to <see cref="T:System.Byte[]"/>.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>The result of the conversion.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Boolean)~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Boolean"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Nullable{System.Boolean})~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Nullable`1"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Int64)~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Nullable`1"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Nullable{System.DateTime})~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Nullable`1"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Nullable{System.Decimal})~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Nullable`1"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Nullable{System.Double})~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Nullable`1"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.UInt16)~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.UInt16"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Int32)~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Int32"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Nullable{System.Int32})~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Nullable`1"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.DateTime)~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.DateTime"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Nullable{System.Int64})~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Nullable`1"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Nullable{System.Single})~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Nullable`1"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Decimal)~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Decimal"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Nullable{System.UInt16})~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Nullable`1"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Nullable{System.UInt32})~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Nullable`1"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Nullable{System.UInt64})~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Nullable`1"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Double)~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Double"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Single)~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Single"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.String)~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.String"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.UInt32)~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.UInt32"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.UInt64)~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.UInt64"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.op_Implicit(System.Byte[])~Newtonsoft.Json.Linq.JToken">

+            <summary>

+            Performs an implicit conversion from <see cref="T:System.Byte[]"/> to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="value">The value to create a <see cref="T:Newtonsoft.Json.Linq.JValue"/> from.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JValue"/> initialized with the specified value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.CreateReader">

+            <summary>

+            Creates an <see cref="T:Newtonsoft.Json.JsonReader"/> for this token.

+            </summary>

+            <returns>An <see cref="T:Newtonsoft.Json.JsonReader"/> that can be used to read this token and its descendants.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.FromObject(System.Object)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Linq.JToken"/> from an object.

+            </summary>

+            <param name="o">The object that will be used to create <see cref="T:Newtonsoft.Json.Linq.JToken"/>.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JToken"/> with the value of the specified object</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.FromObject(System.Object,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Linq.JToken"/> from an object using the specified <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+            <param name="o">The object that will be used to create <see cref="T:Newtonsoft.Json.Linq.JToken"/>.</param>

+            <param name="jsonSerializer">The <see cref="T:Newtonsoft.Json.JsonSerializer"/> that will be used when reading the object.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JToken"/> with the value of the specified object</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.ReadFrom(Newtonsoft.Json.JsonReader)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Linq.JToken"/> from a <see cref="T:Newtonsoft.Json.JsonReader"/>.

+            </summary>

+            <param name="reader">An <see cref="T:Newtonsoft.Json.JsonReader"/> positioned at the token to read into this <see cref="T:Newtonsoft.Json.Linq.JToken"/>.</param>

+            <returns>

+            An <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the token and its descendant tokens

+            that were read from the reader. The runtime type of the token is determined

+            by the token type of the first token encountered in the reader.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.SelectToken(System.String)">

+            <summary>

+            Selects the token that matches the object path.

+            </summary>

+            <param name="path">

+            The object path from the current <see cref="T:Newtonsoft.Json.Linq.JToken"/> to the <see cref="T:Newtonsoft.Json.Linq.JToken"/>

+            to be returned. This must be a string of property names or array indexes separated

+            by periods, such as <code>Tables[0].DefaultView[0].Price</code> in C# or

+            <code>Tables(0).DefaultView(0).Price</code> in Visual Basic.

+            </param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JToken"/> that matches the object path or a null reference if no matching token is found.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JToken.SelectToken(System.String,System.Boolean)">

+            <summary>

+            Selects the token that matches the object path.

+            </summary>

+            <param name="path">

+            The object path from the current <see cref="T:Newtonsoft.Json.Linq.JToken"/> to the <see cref="T:Newtonsoft.Json.Linq.JToken"/>

+            to be returned. This must be a string of property names or array indexes separated

+            by periods, such as <code>Tables[0].DefaultView[0].Price</code> in C# or

+            <code>Tables(0).DefaultView(0).Price</code> in Visual Basic.

+            </param>

+            <param name="errorWhenNoMatch">A flag to indicate whether an error should be thrown if no token is found.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Linq.JToken"/> that matches the object path.</returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JToken.EqualityComparer">

+            <summary>

+            Gets a comparer that can compare two tokens for value equality.

+            </summary>

+            <value>A <see cref="T:Newtonsoft.Json.Linq.JTokenEqualityComparer"/> that can compare two nodes for value equality.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JToken.Parent">

+            <summary>

+            Gets or sets the parent.

+            </summary>

+            <value>The parent.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JToken.Root">

+            <summary>

+            Gets the root <see cref="T:Newtonsoft.Json.Linq.JToken"/> of this <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <value>The root <see cref="T:Newtonsoft.Json.Linq.JToken"/> of this <see cref="T:Newtonsoft.Json.Linq.JToken"/>.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JToken.Type">

+            <summary>

+            Gets the node type for this <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <value>The type.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JToken.HasValues">

+            <summary>

+            Gets a value indicating whether this token has childen tokens.

+            </summary>

+            <value>

+                <c>true</c> if this token has child values; otherwise, <c>false</c>.

+            </value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JToken.Next">

+            <summary>

+            Gets the next sibling token of this node.

+            </summary>

+            <value>The <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the next sibling token.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JToken.Previous">

+            <summary>

+            Gets the previous sibling token of this node.

+            </summary>

+            <value>The <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the previous sibling token.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JToken.Item(System.Object)">

+            <summary>

+            Gets the <see cref="T:Newtonsoft.Json.Linq.JToken"/> with the specified key.

+            </summary>

+            <value>The <see cref="T:Newtonsoft.Json.Linq.JToken"/> with the specified key.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JToken.First">

+            <summary>

+            Get the first child token of this token.

+            </summary>

+            <value>A <see cref="T:Newtonsoft.Json.Linq.JToken"/> containing the first child token of the <see cref="T:Newtonsoft.Json.Linq.JToken"/>.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JToken.Last">

+            <summary>

+            Get the last child token of this token.

+            </summary>

+            <value>A <see cref="T:Newtonsoft.Json.Linq.JToken"/> containing the last child token of the <see cref="T:Newtonsoft.Json.Linq.JToken"/>.</value>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.#ctor(Newtonsoft.Json.Linq.JValue)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JValue"/> class from another <see cref="T:Newtonsoft.Json.Linq.JValue"/> object.

+            </summary>

+            <param name="other">A <see cref="T:Newtonsoft.Json.Linq.JValue"/> object to copy from.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.#ctor(System.Int64)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JValue"/> class with the given value.

+            </summary>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.#ctor(System.UInt64)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JValue"/> class with the given value.

+            </summary>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.#ctor(System.Double)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JValue"/> class with the given value.

+            </summary>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.#ctor(System.DateTime)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JValue"/> class with the given value.

+            </summary>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.#ctor(System.Boolean)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JValue"/> class with the given value.

+            </summary>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.#ctor(System.String)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JValue"/> class with the given value.

+            </summary>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.#ctor(System.Object)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JValue"/> class with the given value.

+            </summary>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.CreateComment(System.String)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Linq.JValue"/> comment with the given value.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JValue"/> comment with the given value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.CreateString(System.String)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Linq.JValue"/> string with the given value.

+            </summary>

+            <param name="value">The value.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JValue"/> string with the given value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.WriteTo(Newtonsoft.Json.JsonWriter,Newtonsoft.Json.JsonConverter[])">

+            <summary>

+            Writes this token to a <see cref="T:Newtonsoft.Json.JsonWriter"/>.

+            </summary>

+            <param name="writer">A <see cref="T:Newtonsoft.Json.JsonWriter"/> into which this method will write.</param>

+            <param name="converters">A collection of <see cref="T:Newtonsoft.Json.JsonConverter"/> which will be used when writing the token.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.Equals(Newtonsoft.Json.Linq.JValue)">

+            <summary>

+            Indicates whether the current object is equal to another object of the same type.

+            </summary>

+            <returns>

+            true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.

+            </returns>

+            <param name="other">An object to compare with this object.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.Equals(System.Object)">

+            <summary>

+            Determines whether the specified <see cref="T:System.Object"/> is equal to the current <see cref="T:System.Object"/>.

+            </summary>

+            <param name="obj">The <see cref="T:System.Object"/> to compare with the current <see cref="T:System.Object"/>.</param>

+            <returns>

+            true if the specified <see cref="T:System.Object"/> is equal to the current <see cref="T:System.Object"/>; otherwise, false.

+            </returns>

+            <exception cref="T:System.NullReferenceException">

+            The <paramref name="obj"/> parameter is null.

+            </exception>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JValue.GetHashCode">

+            <summary>

+            Serves as a hash function for a particular type.

+            </summary>

+            <returns>

+            A hash code for the current <see cref="T:System.Object"/>.

+            </returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JValue.HasValues">

+            <summary>

+            Gets a value indicating whether this token has childen tokens.

+            </summary>

+            <value>

+                <c>true</c> if this token has child values; otherwise, <c>false</c>.

+            </value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JValue.Type">

+            <summary>

+            Gets the node type for this <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <value>The type.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JValue.Value">

+            <summary>

+            Gets or sets the underlying token value.

+            </summary>

+            <value>The underlying token value.</value>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JRaw.#ctor(Newtonsoft.Json.Linq.JRaw)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JRaw"/> class from another <see cref="T:Newtonsoft.Json.Linq.JRaw"/> object.

+            </summary>

+            <param name="other">A <see cref="T:Newtonsoft.Json.Linq.JRaw"/> object to copy from.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JRaw.#ctor(System.String)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JRaw"/> class.

+            </summary>

+            <param name="rawJson">The raw json.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JRaw.Create(Newtonsoft.Json.JsonReader)">

+            <summary>

+            Creates an instance of <see cref="T:Newtonsoft.Json.Linq.JRaw"/> with the content of the reader's current token.

+            </summary>

+            <param name="reader">The reader.</param>

+            <returns>An instance of <see cref="T:Newtonsoft.Json.Linq.JRaw"/> with the content of the reader's current token.</returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Required">

+            <summary>

+            Indicating whether a property is required.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Required.Default">

+            <summary>

+            The property is not required. The default state.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Required.AllowNull">

+            <summary>

+            The property must be defined in JSON but can be a null value.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Required.Always">

+            <summary>

+            The property must be defined in JSON and cannot be a null value.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.IReferenceResolver">

+            <summary>

+            Used to resolve references when serializing and deserializing JSON by the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.IReferenceResolver.ResolveReference(System.String)">

+            <summary>

+            Resolves a reference to its object.

+            </summary>

+            <param name="reference">The reference to resolve.</param>

+            <returns>The object that</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.IReferenceResolver.GetReference(System.Object)">

+            <summary>

+            Gets the reference for the sepecified object.

+            </summary>

+            <param name="value">The object to get a reference for.</param>

+            <returns>The reference to the object.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.IReferenceResolver.IsReferenced(System.Object)">

+            <summary>

+            Determines whether the specified object is referenced.

+            </summary>

+            <param name="value">The object to test for a reference.</param>

+            <returns>

+                <c>true</c> if the specified object is referenced; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.IReferenceResolver.AddReference(System.String,System.Object)">

+            <summary>

+            Adds a reference to the specified object.

+            </summary>

+            <param name="reference">The reference.</param>

+            <param name="value">The object to reference.</param>

+        </member>

+        <member name="T:Newtonsoft.Json.PreserveReferencesHandling">

+            <summary>

+            Specifies reference handling options for the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.PreserveReferencesHandling.None">

+            <summary>

+            Do not preserve references when serializing types.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.PreserveReferencesHandling.Objects">

+            <summary>

+            Preserve references when serializing into a JSON object structure.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.PreserveReferencesHandling.Arrays">

+            <summary>

+            Preserve references when serializing into a JSON array structure.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.PreserveReferencesHandling.All">

+            <summary>

+            Preserve references when serializing.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonArrayAttribute">

+            <summary>

+            Instructs the <see cref="T:Newtonsoft.Json.JsonSerializer"/> how to serialize the collection.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonContainerAttribute">

+            <summary>

+            Instructs the <see cref="T:Newtonsoft.Json.JsonSerializer"/> how to serialize the object.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonContainerAttribute.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonContainerAttribute"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonContainerAttribute.#ctor(System.String)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonContainerAttribute"/> class with the specified container Id.

+            </summary>

+            <param name="id">The container Id.</param>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonContainerAttribute.Id">

+            <summary>

+            Gets or sets the id.

+            </summary>

+            <value>The id.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonContainerAttribute.Title">

+            <summary>

+            Gets or sets the title.

+            </summary>

+            <value>The title.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonContainerAttribute.Description">

+            <summary>

+            Gets or sets the description.

+            </summary>

+            <value>The description.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonContainerAttribute.IsReference">

+            <summary>

+            Gets or sets a value that indicates whether to preserve object reference data.

+            </summary>

+            <value>

+                <c>true</c> to keep object reference; otherwise, <c>false</c>. The default is <c>false</c>.

+            </value>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonArrayAttribute.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonArrayAttribute"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonArrayAttribute.#ctor(System.Boolean)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonObjectAttribute"/> class with a flag indicating whether the array can contain null items

+            </summary>

+            <param name="allowNullItems">A flag indicating whether the array can contain null items.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonArrayAttribute.#ctor(System.String)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonArrayAttribute"/> class with the specified container Id.

+            </summary>

+            <param name="id">The container Id.</param>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonArrayAttribute.AllowNullItems">

+            <summary>

+            Gets or sets a value indicating whether null items are allowed in the collection.

+            </summary>

+            <value><c>true</c> if null items are allowed in the collection; otherwise, <c>false</c>.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.DefaultValueHandling">

+            <summary>

+            Specifies default value handling options for the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.DefaultValueHandling.Include">

+            <summary>

+            Include null values when serializing and deserializing objects.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.DefaultValueHandling.Ignore">

+            <summary>

+            Ignore null values when serializing and deserializing objects.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonConverterAttribute">

+            <summary>

+            Instructs the <see cref="T:Newtonsoft.Json.JsonSerializer"/> to use the specified <see cref="T:Newtonsoft.Json.JsonConverter"/> when serializing the member or class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConverterAttribute.#ctor(System.Type)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonConverterAttribute"/> class.

+            </summary>

+            <param name="converterType">Type of the converter.</param>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonConverterAttribute.ConverterType">

+            <summary>

+            Gets the type of the converter.

+            </summary>

+            <value>The type of the converter.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonObjectAttribute">

+            <summary>

+            Instructs the <see cref="T:Newtonsoft.Json.JsonSerializer"/> how to serialize the object.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonObjectAttribute.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonObjectAttribute"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonObjectAttribute.#ctor(Newtonsoft.Json.MemberSerialization)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonObjectAttribute"/> class with the specified member serialization.

+            </summary>

+            <param name="memberSerialization">The member serialization.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonObjectAttribute.#ctor(System.String)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonObjectAttribute"/> class with the specified container Id.

+            </summary>

+            <param name="id">The container Id.</param>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonObjectAttribute.MemberSerialization">

+            <summary>

+            Gets or sets the member serialization.

+            </summary>

+            <value>The member serialization.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonSerializerSettings">

+            <summary>

+            Specifies the settings on a <see cref="T:Newtonsoft.Json.JsonSerializer"/> object.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializerSettings.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonSerializerSettings"/> class.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.ReferenceLoopHandling">

+            <summary>

+            Gets or sets how reference loops (e.g. a class referencing itself) is handled.

+            </summary>

+            <value>Reference loop handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.MissingMemberHandling">

+            <summary>

+            Gets or sets how missing members (e.g. JSON contains a property that isn't a member on the object) are handled during deserialization.

+            </summary>

+            <value>Missing member handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.ObjectCreationHandling">

+            <summary>

+            Gets or sets how objects are created during deserialization.

+            </summary>

+            <value>The object creation handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.NullValueHandling">

+            <summary>

+            Gets or sets how null values are handled during serialization and deserialization.

+            </summary>

+            <value>Null value handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.DefaultValueHandling">

+            <summary>

+            Gets or sets how null default are handled during serialization and deserialization.

+            </summary>

+            <value>The default value handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.Converters">

+            <summary>

+            Gets or sets a collection <see cref="T:Newtonsoft.Json.JsonConverter"/> that will be used during serialization.

+            </summary>

+            <value>The converters.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.PreserveReferencesHandling">

+            <summary>

+            Gets or sets how object references are preserved by the serializer.

+            </summary>

+            <value>The preserve references handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.TypeNameHandling">

+            <summary>

+            Gets or sets how type name writing and reading is handled by the serializer.

+            </summary>

+            <value>The type name handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.ConstructorHandling">

+            <summary>

+            Gets or sets how constructors are used during deserialization.

+            </summary>

+            <value>The constructor handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.ContractResolver">

+            <summary>

+            Gets or sets the contract resolver used by the serializer when

+            serializing .NET objects to JSON and vice versa.

+            </summary>

+            <value>The contract resolver.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.ReferenceResolver">

+            <summary>

+            Gets or sets the <see cref="T:Newtonsoft.Json.Serialization.IReferenceResolver"/> used by the serializer when resolving references.

+            </summary>

+            <value>The reference resolver.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.Binder">

+            <summary>

+            Gets or sets the <see cref="T:System.Runtime.Serialization.SerializationBinder"/> used by the serializer when resolving type names.

+            </summary>

+            <value>The binder.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.Error">

+            <summary>

+            Gets or sets the error handler called during serialization and deserialization.

+            </summary>

+            <value>The error handler called during serialization and deserialization.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializerSettings.Context">

+            <summary>

+            Gets or sets the <see cref="T:System.Runtime.Serialization.StreamingContext"/> used by the serializer when invoking serialization callback methods.

+            </summary>

+            <value>The context.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonValidatingReader">

+            <summary>

+            Represents a reader that provides <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> validation.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonValidatingReader.#ctor(Newtonsoft.Json.JsonReader)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonValidatingReader"/> class that

+            validates the content returned from the given <see cref="T:Newtonsoft.Json.JsonReader"/>.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read from while validating.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonValidatingReader.ReadAsBytes">

+            <summary>

+            Reads the next JSON token from the stream as a <see cref="T:Byte[]"/>.

+            </summary>

+            <returns>

+            A <see cref="T:Byte[]"/> or a null reference if the next JSON token is null.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonValidatingReader.Read">

+            <summary>

+            Reads the next JSON token from the stream.

+            </summary>

+            <returns>

+            true if the next token was read successfully; false if there are no more tokens to read.

+            </returns>

+        </member>

+        <member name="E:Newtonsoft.Json.JsonValidatingReader.ValidationEventHandler">

+            <summary>

+            Sets an event handler for receiving schema validation errors.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonValidatingReader.Value">

+            <summary>

+            Gets the text value of the current Json token.

+            </summary>

+            <value></value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonValidatingReader.Depth">

+            <summary>

+            Gets the depth of the current token in the JSON document.

+            </summary>

+            <value>The depth of the current token in the JSON document.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonValidatingReader.QuoteChar">

+            <summary>

+            Gets the quotation mark character used to enclose the value of a string.

+            </summary>

+            <value></value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonValidatingReader.TokenType">

+            <summary>

+            Gets the type of the current Json token.

+            </summary>

+            <value></value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonValidatingReader.ValueType">

+            <summary>

+            Gets The Common Language Runtime (CLR) type for the current Json token.

+            </summary>

+            <value></value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonValidatingReader.Schema">

+            <summary>

+            Gets or sets the schema.

+            </summary>

+            <value>The schema.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonValidatingReader.Reader">

+            <summary>

+            Gets the <see cref="T:Newtonsoft.Json.JsonReader"/> used to construct this <see cref="T:Newtonsoft.Json.JsonValidatingReader"/>.

+            </summary>

+            <value>The <see cref="T:Newtonsoft.Json.JsonReader"/> specified in the constructor.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.JTokenEqualityComparer">

+            <summary>

+            Compares tokens to determine whether they are equal.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenEqualityComparer.Equals(Newtonsoft.Json.Linq.JToken,Newtonsoft.Json.Linq.JToken)">

+            <summary>

+            Determines whether the specified objects are equal.

+            </summary>

+            <param name="x">The first object of type <paramref name="T"/> to compare.</param>

+            <param name="y">The second object of type <paramref name="T"/> to compare.</param>

+            <returns>

+            true if the specified objects are equal; otherwise, false.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenEqualityComparer.GetHashCode(Newtonsoft.Json.Linq.JToken)">

+            <summary>

+            Returns a hash code for the specified object.

+            </summary>

+            <param name="obj">The <see cref="T:System.Object"/> for which a hash code is to be returned.</param>

+            <returns>A hash code for the specified object.</returns>

+            <exception cref="T:System.ArgumentNullException">The type of <paramref name="obj"/> is a reference type and <paramref name="obj"/> is null.</exception>

+        </member>

+        <member name="T:Newtonsoft.Json.MemberSerialization">

+            <summary>

+            Specifies the member serialization options for the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.MemberSerialization.OptOut">

+            <summary>

+            All members are serialized by default. Members can be excluded using the <see cref="T:Newtonsoft.Json.JsonIgnoreAttribute"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.MemberSerialization.OptIn">

+            <summary>

+            Only members must be marked with the <see cref="T:Newtonsoft.Json.JsonPropertyAttribute"/> are serialized.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.ObjectCreationHandling">

+            <summary>

+            Specifies how object creation is handled by the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.ObjectCreationHandling.Auto">

+            <summary>

+            Reuse existing objects, create new objects when needed.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.ObjectCreationHandling.Reuse">

+            <summary>

+            Only reuse existing objects.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.ObjectCreationHandling.Replace">

+            <summary>

+            Always create new objects.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Converters.IsoDateTimeConverter">

+            <summary>

+            Converts a <see cref="T:System.DateTime"/> to and from the ISO 8601 date format (e.g. 2008-04-12T12:53Z).

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.IsoDateTimeConverter.WriteJson(Newtonsoft.Json.JsonWriter,System.Object,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Writes the JSON representation of the object.

+            </summary>

+            <param name="writer">The <see cref="T:Newtonsoft.Json.JsonWriter"/> to write to.</param>

+            <param name="value">The value.</param>

+            <param name="serializer">The calling serializer.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.IsoDateTimeConverter.ReadJson(Newtonsoft.Json.JsonReader,System.Type,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Reads the JSON representation of the object.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read from.</param>

+            <param name="objectType">Type of the object.</param>

+            <param name="serializer">The calling serializer.</param>

+            <returns>The object value.</returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Converters.IsoDateTimeConverter.DateTimeStyles">

+            <summary>

+            Gets or sets the date time styles used when converting a date to and from JSON.

+            </summary>

+            <value>The date time styles used when converting a date to and from JSON.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Converters.IsoDateTimeConverter.DateTimeFormat">

+            <summary>

+            Gets or sets the date time format used when converting a date to and from JSON.

+            </summary>

+            <value>The date time format used when converting a date to and from JSON.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Converters.IsoDateTimeConverter.Culture">

+            <summary>

+            Gets or sets the culture used when converting a date to and from JSON.

+            </summary>

+            <value>The culture used when converting a date to and from JSON.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Converters.JavaScriptDateTimeConverter">

+            <summary>

+            Converts a <see cref="T:System.DateTime"/> to and from a JavaScript date constructor (e.g. new Date(52231943)).

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.JavaScriptDateTimeConverter.WriteJson(Newtonsoft.Json.JsonWriter,System.Object,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Writes the JSON representation of the object.

+            </summary>

+            <param name="writer">The <see cref="T:Newtonsoft.Json.JsonWriter"/> to write to.</param>

+            <param name="value">The value.</param>

+            <param name="serializer">The calling serializer.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.JavaScriptDateTimeConverter.ReadJson(Newtonsoft.Json.JsonReader,System.Type,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Reads the JSON representation of the object.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read from.</param>

+            <param name="objectType">Type of the object.</param>

+            <param name="serializer">The calling serializer.</param>

+            <returns>The object value.</returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Converters.JsonDateTimeSerializationMode">

+            <summary>

+            Specifies whether a DateTime object represents a local time, a Coordinated Universal Time (UTC), or is not specified as either local time or UTC.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Converters.JsonDateTimeSerializationMode.Local">

+            <summary>

+            The time represented is local time.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Converters.JsonDateTimeSerializationMode.Utc">

+            <summary>

+            The time represented is UTC.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Converters.JsonDateTimeSerializationMode.Unspecified">

+            <summary>

+            The time represented is not specified as either local time or Coordinated Universal Time (UTC).

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Converters.JsonDateTimeSerializationMode.RoundtripKind">

+            <summary>

+            Preserves the DateTimeKind field of a date when a DateTime object is converted to a string and the string is then converted back to a DateTime object.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Converters.XmlNodeConverter">

+            <summary>

+            Converts an <see cref="T:System.Xml.XmlNode"/> to and from JSON.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.XmlNodeConverter.WriteJson(Newtonsoft.Json.JsonWriter,System.Object,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Writes the JSON representation of the object.

+            </summary>

+            <param name="writer">The <see cref="T:Newtonsoft.Json.JsonWriter"/> to write to.</param>

+            <param name="serializer">The calling serializer.</param>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.XmlNodeConverter.ReadJson(Newtonsoft.Json.JsonReader,System.Type,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Reads the JSON representation of the object.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read from.</param>

+            <param name="objectType">Type of the object.</param>

+            <param name="serializer">The calling serializer.</param>

+            <returns>The object value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.XmlNodeConverter.IsNamespaceAttribute(System.String,System.String@)">

+            <summary>

+            Checks if the attributeName is a namespace attribute.

+            </summary>

+            <param name="attributeName">Attribute name to test.</param>

+            <param name="prefix">The attribute name prefix if it has one, otherwise an empty string.</param>

+            <returns>True if attribute name is for a namespace attribute, otherwise false.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.XmlNodeConverter.CanConvert(System.Type)">

+            <summary>

+            Determines whether this instance can convert the specified value type.

+            </summary>

+            <param name="valueType">Type of the value.</param>

+            <returns>

+                <c>true</c> if this instance can convert the specified value type; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Converters.XmlNodeConverter.DeserializeRootElementName">

+            <summary>

+            Gets or sets the name of the root element to insert when deserializing to XML if the JSON structure has produces multiple root elements.

+            </summary>

+            <value>The name of the deserialize root element.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Converters.HtmlColorConverter">

+            <summary>

+            Converts a <see cref="T:System.Drawing.Color"/> object to and from JSON.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.HtmlColorConverter.WriteJson(Newtonsoft.Json.JsonWriter,System.Object,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Writes the JSON representation of the object.

+            </summary>

+            <param name="writer">The <see cref="T:Newtonsoft.Json.JsonWriter"/> to write to.</param>

+            <param name="serializer">The calling serializer.</param>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.HtmlColorConverter.CanConvert(System.Type)">

+            <summary>

+            Determines whether this instance can convert the specified value type.

+            </summary>

+            <param name="valueType">Type of the value.</param>

+            <returns>

+                <c>true</c> if this instance can convert the specified value type; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Converters.HtmlColorConverter.ReadJson(Newtonsoft.Json.JsonReader,System.Type,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Reads the JSON representation of the object.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> to read from.</param>

+            <param name="objectType">Type of the object.</param>

+            <param name="serializer">The calling serializer.</param>

+            <returns>The object value.</returns>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonTextReader">

+            <summary>

+            Represents a reader that provides fast, non-cached, forward-only access to serialized Json data.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextReader.#ctor(System.IO.TextReader)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonReader"/> class with the specified <see cref="T:System.IO.TextReader"/>.

+            </summary>

+            <param name="reader">The <c>TextReader</c> containing the XML data to read.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextReader.Read">

+            <summary>

+            Reads the next JSON token from the stream.

+            </summary>

+            <returns>

+            true if the next token was read successfully; false if there are no more tokens to read.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextReader.ReadAsBytes">

+            <summary>

+            Reads the next JSON token from the stream as a <see cref="T:Byte[]"/>.

+            </summary>

+            <returns>

+            A <see cref="T:Byte[]"/> or a null reference if the next JSON token is null.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextReader.Close">

+            <summary>

+            Changes the state to closed. 

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextReader.HasLineInfo">

+            <summary>

+            Gets a value indicating whether the class can return line information.

+            </summary>

+            <returns>

+                <c>true</c> if LineNumber and LinePosition can be provided; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonTextReader.LineNumber">

+            <summary>

+            Gets the current line number.

+            </summary>

+            <value>

+            The current line number or 0 if no line information is available (for example, HasLineInfo returns false).

+            </value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonTextReader.LinePosition">

+            <summary>

+            Gets the current line position.

+            </summary>

+            <value>

+            The current line position or 0 if no line information is available (for example, HasLineInfo returns false).

+            </value>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonPropertyAttribute">

+            <summary>

+            Instructs the <see cref="T:Newtonsoft.Json.JsonSerializer"/> to always serialize the member with the specified name.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonPropertyAttribute.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonPropertyAttribute"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonPropertyAttribute.#ctor(System.String)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonPropertyAttribute"/> class with the specified name.

+            </summary>

+            <param name="propertyName">Name of the property.</param>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonPropertyAttribute.NullValueHandling">

+            <summary>

+            Gets or sets the null value handling used when serializing this property.

+            </summary>

+            <value>The null value handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonPropertyAttribute.DefaultValueHandling">

+            <summary>

+            Gets or sets the default value handling used when serializing this property.

+            </summary>

+            <value>The default value handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonPropertyAttribute.ReferenceLoopHandling">

+            <summary>

+            Gets or sets the reference loop handling used when serializing this property.

+            </summary>

+            <value>The reference loop handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonPropertyAttribute.ObjectCreationHandling">

+            <summary>

+            Gets or sets the object creation handling used when deserializing this property.

+            </summary>

+            <value>The object creation handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonPropertyAttribute.IsReference">

+            <summary>

+            Gets or sets whether this property's value is serialized as a reference.

+            </summary>

+            <value>Whether this property's value is serialized as a reference.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonPropertyAttribute.PropertyName">

+            <summary>

+            Gets or sets the name of the property.

+            </summary>

+            <value>The name of the property.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonPropertyAttribute.Required">

+            <summary>

+            Gets or sets a value indicating whether this property is required.

+            </summary>

+            <value>

+                A value indicating whether this property is required.

+            </value>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonIgnoreAttribute">

+            <summary>

+            Instructs the <see cref="T:Newtonsoft.Json.JsonSerializer"/> not to serialize the public field or public read/write property value.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonTextWriter">

+            <summary>

+            Represents a writer that provides a fast, non-cached, forward-only way of generating Json data.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.#ctor(System.IO.TextWriter)">

+            <summary>

+            Creates an instance of the <c>JsonWriter</c> class using the specified <see cref="T:System.IO.TextWriter"/>. 

+            </summary>

+            <param name="textWriter">The <c>TextWriter</c> to write to.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.Flush">

+            <summary>

+            Flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.Close">

+            <summary>

+            Closes this stream and the underlying stream.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteStartObject">

+            <summary>

+            Writes the beginning of a Json object.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteStartArray">

+            <summary>

+            Writes the beginning of a Json array.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteStartConstructor(System.String)">

+            <summary>

+            Writes the start of a constructor with the given name.

+            </summary>

+            <param name="name">The name of the constructor.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteEnd(Newtonsoft.Json.JsonToken)">

+            <summary>

+            Writes the specified end token.

+            </summary>

+            <param name="token">The end token to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WritePropertyName(System.String)">

+            <summary>

+            Writes the property name of a name/value pair on a Json object.

+            </summary>

+            <param name="name">The name of the property.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteIndent">

+            <summary>

+            Writes indent characters.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValueDelimiter">

+            <summary>

+            Writes the JSON value delimiter.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteIndentSpace">

+            <summary>

+            Writes an indent space.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteNull">

+            <summary>

+            Writes a null value.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteUndefined">

+            <summary>

+            Writes an undefined value.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteRaw(System.String)">

+            <summary>

+            Writes raw JSON.

+            </summary>

+            <param name="json">The raw JSON to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.String)">

+            <summary>

+            Writes a <see cref="T:System.String"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.String"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.Int32)">

+            <summary>

+            Writes a <see cref="T:System.Int32"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Int32"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.UInt32)">

+            <summary>

+            Writes a <see cref="T:System.UInt32"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.UInt32"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.Int64)">

+            <summary>

+            Writes a <see cref="T:System.Int64"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Int64"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.UInt64)">

+            <summary>

+            Writes a <see cref="T:System.UInt64"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.UInt64"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.Single)">

+            <summary>

+            Writes a <see cref="T:System.Single"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Single"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.Double)">

+            <summary>

+            Writes a <see cref="T:System.Double"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Double"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.Boolean)">

+            <summary>

+            Writes a <see cref="T:System.Boolean"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Boolean"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.Int16)">

+            <summary>

+            Writes a <see cref="T:System.Int16"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Int16"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.UInt16)">

+            <summary>

+            Writes a <see cref="T:System.UInt16"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.UInt16"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.Char)">

+            <summary>

+            Writes a <see cref="T:System.Char"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Char"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.Byte)">

+            <summary>

+            Writes a <see cref="T:System.Byte"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Byte"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.SByte)">

+            <summary>

+            Writes a <see cref="T:System.SByte"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.SByte"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.Decimal)">

+            <summary>

+            Writes a <see cref="T:System.Decimal"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.Decimal"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.DateTime)">

+            <summary>

+            Writes a <see cref="T:System.DateTime"/> value.

+            </summary>

+            <param name="value">The <see cref="T:System.DateTime"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteValue(System.Byte[])">

+            <summary>

+            Writes a <see cref="T:Byte[]"/> value.

+            </summary>

+            <param name="value">The <see cref="T:Byte[]"/> value to write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteComment(System.String)">

+            <summary>

+            Writes out a comment <code>/*...*/</code> containing the specified text. 

+            </summary>

+            <param name="text">Text to place inside the comment.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonTextWriter.WriteWhitespace(System.String)">

+            <summary>

+            Writes out the given white space.

+            </summary>

+            <param name="ws">The string of white space characters.</param>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonTextWriter.Indentation">

+            <summary>

+            Gets or sets how many IndentChars to write for each level in the hierarchy when <paramref name="Formatting"/> is set to <c>Formatting.Indented</c>.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonTextWriter.QuoteChar">

+            <summary>

+            Gets or sets which character to use to quote attribute values.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonTextWriter.IndentChar">

+            <summary>

+            Gets or sets which character to use for indenting when <paramref name="Formatting"/> is set to <c>Formatting.Indented</c>.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonTextWriter.QuoteName">

+            <summary>

+            Gets or sets a value indicating whether object names will be surrounded with quotes.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonWriterException">

+            <summary>

+            The exception thrown when an error occurs while reading Json text.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriterException.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonWriterException"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriterException.#ctor(System.String)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonWriterException"/> class

+            with a specified error message.

+            </summary>

+            <param name="message">The error message that explains the reason for the exception.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonWriterException.#ctor(System.String,System.Exception)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonWriterException"/> class

+            with a specified error message and a reference to the inner exception that is the cause of this exception.

+            </summary>

+            <param name="message">The error message that explains the reason for the exception.</param>

+            <param name="innerException">The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified.</param>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonReaderException">

+            <summary>

+            The exception thrown when an error occurs while reading Json text.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonReaderException.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonReaderException"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonReaderException.#ctor(System.String)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonReaderException"/> class

+            with a specified error message.

+            </summary>

+            <param name="message">The error message that explains the reason for the exception.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonReaderException.#ctor(System.String,System.Exception)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonReaderException"/> class

+            with a specified error message and a reference to the inner exception that is the cause of this exception.

+            </summary>

+            <param name="message">The error message that explains the reason for the exception.</param>

+            <param name="innerException">The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified.</param>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonReaderException.LineNumber">

+            <summary>

+            Gets the line number indicating where the error occurred.

+            </summary>

+            <value>The line number indicating where the error occurred.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonReaderException.LinePosition">

+            <summary>

+            Gets the line position indicating where the error occurred.

+            </summary>

+            <value>The line position indicating where the error occurred.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonConverterCollection">

+            <summary>

+            Represents a collection of <see cref="T:Newtonsoft.Json.JsonConverter"/>.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonConvert">

+            <summary>

+            Provides methods for converting between common language runtime types and JSON types.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonConvert.True">

+            <summary>

+            Represents JavaScript's boolean value true as a string. This field is read-only.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonConvert.False">

+            <summary>

+            Represents JavaScript's boolean value false as a string. This field is read-only.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonConvert.Null">

+            <summary>

+            Represents JavaScript's null as a string. This field is read-only.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonConvert.Undefined">

+            <summary>

+            Represents JavaScript's undefined as a string. This field is read-only.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonConvert.PositiveInfinity">

+            <summary>

+            Represents JavaScript's positive infinity as a string. This field is read-only.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonConvert.NegativeInfinity">

+            <summary>

+            Represents JavaScript's negative infinity as a string. This field is read-only.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonConvert.NaN">

+            <summary>

+            Represents JavaScript's NaN as a string. This field is read-only.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.DateTime)">

+            <summary>

+            Converts the <see cref="T:System.DateTime"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.DateTime"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.Boolean)">

+            <summary>

+            Converts the <see cref="T:System.Boolean"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.Boolean"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.Char)">

+            <summary>

+            Converts the <see cref="T:System.Char"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.Char"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.Enum)">

+            <summary>

+            Converts the <see cref="T:System.Enum"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.Enum"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.Int32)">

+            <summary>

+            Converts the <see cref="T:System.Int32"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.Int32"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.Int16)">

+            <summary>

+            Converts the <see cref="T:System.Int16"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.Int16"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.UInt16)">

+            <summary>

+            Converts the <see cref="T:System.UInt16"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.UInt16"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.UInt32)">

+            <summary>

+            Converts the <see cref="T:System.UInt32"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.UInt32"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.Int64)">

+            <summary>

+            Converts the <see cref="T:System.Int64"/>  to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.Int64"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.UInt64)">

+            <summary>

+            Converts the <see cref="T:System.UInt64"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.UInt64"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.Single)">

+            <summary>

+            Converts the <see cref="T:System.Single"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.Single"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.Double)">

+            <summary>

+            Converts the <see cref="T:System.Double"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.Double"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.Byte)">

+            <summary>

+            Converts the <see cref="T:System.Byte"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.Byte"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.SByte)">

+            <summary>

+            Converts the <see cref="T:System.SByte"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.SByte"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.Decimal)">

+            <summary>

+            Converts the <see cref="T:System.Decimal"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.SByte"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.Guid)">

+            <summary>

+            Converts the <see cref="T:System.Guid"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.Guid"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.String)">

+            <summary>

+            Converts the <see cref="T:System.String"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.String"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.String,System.Char)">

+            <summary>

+            Converts the <see cref="T:System.String"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <param name="delimter">The string delimiter character.</param>

+            <returns>A JSON string representation of the <see cref="T:System.String"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.ToString(System.Object)">

+            <summary>

+            Converts the <see cref="T:System.Object"/> to its JSON string representation.

+            </summary>

+            <param name="value">The value to convert.</param>

+            <returns>A JSON string representation of the <see cref="T:System.Object"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.SerializeObject(System.Object)">

+            <summary>

+            Serializes the specified object to a JSON string.

+            </summary>

+            <param name="value">The object to serialize.</param>

+            <returns>A JSON string representation of the object.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.SerializeObject(System.Object,Newtonsoft.Json.Formatting)">

+            <summary>

+            Serializes the specified object to a JSON string.

+            </summary>

+            <param name="value">The object to serialize.</param>

+            <param name="formatting">Indicates how the output is formatted.</param>

+            <returns>

+            A JSON string representation of the object.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.SerializeObject(System.Object,Newtonsoft.Json.JsonConverter[])">

+            <summary>

+            Serializes the specified object to a JSON string using a collection of <see cref="T:Newtonsoft.Json.JsonConverter"/>.

+            </summary>

+            <param name="value">The object to serialize.</param>

+            <param name="converters">A collection converters used while serializing.</param>

+            <returns>A JSON string representation of the object.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.SerializeObject(System.Object,Newtonsoft.Json.Formatting,Newtonsoft.Json.JsonConverter[])">

+            <summary>

+            Serializes the specified object to a JSON string using a collection of <see cref="T:Newtonsoft.Json.JsonConverter"/>.

+            </summary>

+            <param name="value">The object to serialize.</param>

+            <param name="formatting">Indicates how the output is formatted.</param>

+            <param name="converters">A collection converters used while serializing.</param>

+            <returns>A JSON string representation of the object.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.SerializeObject(System.Object,Newtonsoft.Json.Formatting,Newtonsoft.Json.JsonSerializerSettings)">

+            <summary>

+            Serializes the specified object to a JSON string using a collection of <see cref="T:Newtonsoft.Json.JsonConverter"/>.

+            </summary>

+            <param name="value">The object to serialize.</param>

+            <param name="formatting">Indicates how the output is formatted.</param>

+            <param name="settings">The <see cref="T:Newtonsoft.Json.JsonSerializerSettings"/> used to serialize the object.

+            If this is null, default serialization settings will be is used.</param>

+            <returns>

+            A JSON string representation of the object.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.DeserializeObject(System.String)">

+            <summary>

+            Deserializes the specified object to a Json object.

+            </summary>

+            <param name="value">The object to deserialize.</param>

+            <returns>The deserialized object from the Json string.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.DeserializeObject(System.String,System.Type)">

+            <summary>

+            Deserializes the specified object to a Json object.

+            </summary>

+            <param name="value">The object to deserialize.</param>

+            <param name="type">The <see cref="T:System.Type"/> of object being deserialized.</param>

+            <returns>The deserialized object from the Json string.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.DeserializeObject``1(System.String)">

+            <summary>

+            Deserializes the specified object to a Json object.

+            </summary>

+            <typeparam name="T">The type of the object to deserialize.</typeparam>

+            <param name="value">The object to deserialize.</param>

+            <returns>The deserialized object from the Json string.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.DeserializeAnonymousType``1(System.String,``0)">

+            <summary>

+            Deserializes the specified JSON to the given anonymous type.

+            </summary>

+            <typeparam name="T">

+            The anonymous type to deserialize to. This can't be specified

+            traditionally and must be infered from the anonymous type passed

+            as a parameter.

+            </typeparam>

+            <param name="value">The object to deserialize.</param>

+            <param name="anonymousTypeObject">The anonymous type object.</param>

+            <returns>The deserialized anonymous type from the JSON string.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.DeserializeObject``1(System.String,Newtonsoft.Json.JsonConverter[])">

+            <summary>

+            Deserializes the JSON string to the specified type.

+            </summary>

+            <typeparam name="T">The type of the object to deserialize.</typeparam>

+            <param name="value">The object to deserialize.</param>

+            <param name="converters">Converters to use while deserializing.</param>

+            <returns>The deserialized object from the JSON string.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.DeserializeObject``1(System.String,Newtonsoft.Json.JsonSerializerSettings)">

+            <summary>

+            Deserializes the JSON string to the specified type.

+            </summary>

+            <typeparam name="T">The type of the object to deserialize.</typeparam>

+            <param name="value">The object to deserialize.</param>

+            <param name="settings">

+            The <see cref="T:Newtonsoft.Json.JsonSerializerSettings"/> used to deserialize the object.

+            If this is null, default serialization settings will be is used.

+            </param>

+            <returns>The deserialized object from the JSON string.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.DeserializeObject(System.String,System.Type,Newtonsoft.Json.JsonConverter[])">

+            <summary>

+            Deserializes the JSON string to the specified type.

+            </summary>

+            <param name="value">The object to deserialize.</param>

+            <param name="type">The type of the object to deserialize.</param>

+            <param name="converters">Converters to use while deserializing.</param>

+            <returns>The deserialized object from the JSON string.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.DeserializeObject(System.String,System.Type,Newtonsoft.Json.JsonSerializerSettings)">

+            <summary>

+            Deserializes the JSON string to the specified type.

+            </summary>

+            <param name="value">The JSON to deserialize.</param>

+            <param name="type">The type of the object to deserialize.</param>

+            <param name="settings">

+            The <see cref="T:Newtonsoft.Json.JsonSerializerSettings"/> used to deserialize the object.

+            If this is null, default serialization settings will be is used.

+            </param>

+            <returns>The deserialized object from the JSON string.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.PopulateObject(System.String,System.Object)">

+            <summary>

+            Populates the object with values from the JSON string.

+            </summary>

+            <param name="value">The JSON to populate values from.</param>

+            <param name="target">The target object to populate values onto.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.PopulateObject(System.String,System.Object,Newtonsoft.Json.JsonSerializerSettings)">

+            <summary>

+            Populates the object with values from the JSON string.

+            </summary>

+            <param name="value">The JSON to populate values from.</param>

+            <param name="target">The target object to populate values onto.</param>

+            <param name="settings">

+            The <see cref="T:Newtonsoft.Json.JsonSerializerSettings"/> used to deserialize the object.

+            If this is null, default serialization settings will be is used.

+            </param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.SerializeXmlNode(System.Xml.XmlNode)">

+            <summary>

+            Serializes the XML node to a JSON string.

+            </summary>

+            <param name="node">The node to serialize.</param>

+            <returns>A JSON string of the XmlNode.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.DeserializeXmlNode(System.String)">

+            <summary>

+            Deserializes the XmlNode from a JSON string.

+            </summary>

+            <param name="value">The JSON string.</param>

+            <returns>The deserialized XmlNode</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonConvert.DeserializeXmlNode(System.String,System.String)">

+            <summary>

+            Deserializes the XmlNode from a JSON string nested in a root elment.

+            </summary>

+            <param name="value">The JSON string.</param>

+            <param name="deserializeRootElementName">The name of the root element to append when deserializing.</param>

+            <returns>The deserialized XmlNode</returns>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonSerializationException">

+            <summary>

+            The exception thrown when an error occurs during Json serialization or deserialization.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializationException.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonSerializationException"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializationException.#ctor(System.String)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonSerializationException"/> class

+            with a specified error message.

+            </summary>

+            <param name="message">The error message that explains the reason for the exception.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializationException.#ctor(System.String,System.Exception)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonSerializationException"/> class

+            with a specified error message and a reference to the inner exception that is the cause of this exception.

+            </summary>

+            <param name="message">The error message that explains the reason for the exception.</param>

+            <param name="innerException">The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified.</param>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonSerializer">

+            <summary>

+            Serializes and deserializes objects into and from the JSON format.

+            The <see cref="T:Newtonsoft.Json.JsonSerializer"/> enables you to control how objects are encoded into JSON.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializer.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.JsonSerializer"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializer.Create(Newtonsoft.Json.JsonSerializerSettings)">

+            <summary>

+            Creates a new <see cref="T:Newtonsoft.Json.JsonSerializer"/> instance using the specified <see cref="T:Newtonsoft.Json.JsonSerializerSettings"/>.

+            </summary>

+            <param name="settings">The settings to be applied to the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.</param>

+            <returns>A new <see cref="T:Newtonsoft.Json.JsonSerializer"/> instance using the specified <see cref="T:Newtonsoft.Json.JsonSerializerSettings"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializer.Populate(System.IO.TextReader,System.Object)">

+            <summary>

+            Populates the JSON values onto the target object.

+            </summary>

+            <param name="reader">The <see cref="T:System.IO.TextReader"/> that contains the JSON structure to reader values from.</param>

+            <param name="target">The target object to populate values onto.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializer.Populate(Newtonsoft.Json.JsonReader,System.Object)">

+            <summary>

+            Populates the JSON values onto the target object.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> that contains the JSON structure to reader values from.</param>

+            <param name="target">The target object to populate values onto.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializer.Deserialize(Newtonsoft.Json.JsonReader)">

+            <summary>

+            Deserializes the Json structure contained by the specified <see cref="T:Newtonsoft.Json.JsonReader"/>.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> that contains the JSON structure to deserialize.</param>

+            <returns>The <see cref="T:System.Object"/> being deserialized.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializer.Deserialize(System.IO.TextReader,System.Type)">

+            <summary>

+            Deserializes the Json structure contained by the specified <see cref="T:System.IO.StringReader"/>

+            into an instance of the specified type.

+            </summary>

+            <param name="reader">The <see cref="T:System.IO.TextReader"/> containing the object.</param>

+            <param name="objectType">The <see cref="T:System.Type"/> of object being deserialized.</param>

+            <returns>The instance of <paramref name="objectType"/> being deserialized.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializer.Deserialize``1(Newtonsoft.Json.JsonReader)">

+            <summary>

+            Deserializes the Json structure contained by the specified <see cref="T:Newtonsoft.Json.JsonReader"/>

+            into an instance of the specified type.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> containing the object.</param>

+            <typeparam name="T">The type of the object to deserialize.</typeparam>

+            <returns>The instance of <typeparamref name="T"/> being deserialized.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializer.Deserialize(Newtonsoft.Json.JsonReader,System.Type)">

+            <summary>

+            Deserializes the Json structure contained by the specified <see cref="T:Newtonsoft.Json.JsonReader"/>

+            into an instance of the specified type.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> containing the object.</param>

+            <param name="objectType">The <see cref="T:System.Type"/> of object being deserialized.</param>

+            <returns>The instance of <paramref name="objectType"/> being deserialized.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializer.Serialize(System.IO.TextWriter,System.Object)">

+            <summary>

+            Serializes the specified <see cref="T:System.Object"/> and writes the Json structure

+            to a <c>Stream</c> using the specified <see cref="T:System.IO.TextWriter"/>. 

+            </summary>

+            <param name="textWriter">The <see cref="T:System.IO.TextWriter"/> used to write the Json structure.</param>

+            <param name="value">The <see cref="T:System.Object"/> to serialize.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.JsonSerializer.Serialize(Newtonsoft.Json.JsonWriter,System.Object)">

+            <summary>

+            Serializes the specified <see cref="T:System.Object"/> and writes the Json structure

+            to a <c>Stream</c> using the specified <see cref="T:Newtonsoft.Json.JsonWriter"/>. 

+            </summary>

+            <param name="jsonWriter">The <see cref="T:Newtonsoft.Json.JsonWriter"/> used to write the Json structure.</param>

+            <param name="value">The <see cref="T:System.Object"/> to serialize.</param>

+        </member>

+        <member name="E:Newtonsoft.Json.JsonSerializer.Error">

+            <summary>

+            Occurs when the <see cref="T:Newtonsoft.Json.JsonSerializer"/> errors during serialization and deserialization.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializer.ReferenceResolver">

+            <summary>

+            Gets or sets the <see cref="T:Newtonsoft.Json.Serialization.IReferenceResolver"/> used by the serializer when resolving references.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializer.Binder">

+            <summary>

+            Gets or sets the <see cref="T:System.Runtime.Serialization.SerializationBinder"/> used by the serializer when resolving type names.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializer.TypeNameHandling">

+            <summary>

+            Gets or sets how type name writing and reading is handled by the serializer.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializer.PreserveReferencesHandling">

+            <summary>

+            Gets or sets how object references are preserved by the serializer.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializer.ReferenceLoopHandling">

+            <summary>

+            Get or set how reference loops (e.g. a class referencing itself) is handled.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializer.MissingMemberHandling">

+            <summary>

+            Get or set how missing members (e.g. JSON contains a property that isn't a member on the object) are handled during deserialization.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializer.NullValueHandling">

+            <summary>

+            Get or set how null values are handled during serialization and deserialization.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializer.DefaultValueHandling">

+            <summary>

+            Get or set how null default are handled during serialization and deserialization.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializer.ObjectCreationHandling">

+            <summary>

+            Gets or sets how objects are created during deserialization.

+            </summary>

+            <value>The object creation handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializer.ConstructorHandling">

+            <summary>

+            Gets or sets how constructors are used during deserialization.

+            </summary>

+            <value>The constructor handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializer.Converters">

+            <summary>

+            Gets a collection <see cref="T:Newtonsoft.Json.JsonConverter"/> that will be used during serialization.

+            </summary>

+            <value>Collection <see cref="T:Newtonsoft.Json.JsonConverter"/> that will be used during serialization.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializer.ContractResolver">

+            <summary>

+            Gets or sets the contract resolver used by the serializer when

+            serializing .NET objects to JSON and vice versa.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.JsonSerializer.Context">

+            <summary>

+            Gets or sets the <see cref="T:System.Runtime.Serialization.StreamingContext"/> used by the serializer when invoking serialization callback methods.

+            </summary>

+            <value>The context.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.Extensions">

+            <summary>

+            Contains the LINQ to JSON extension methods.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.Extensions.Ancestors``1(System.Collections.Generic.IEnumerable{``0})">

+            <summary>

+            Returns a collection of tokens that contains the ancestors of every token in the source collection.

+            </summary>

+            <typeparam name="T">The type of the objects in source, constrained to <see cref="T:Newtonsoft.Json.Linq.JToken"/>.</typeparam>

+            <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the source collection.</param>

+            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the ancestors of every node in the source collection.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.Extensions.Descendants``1(System.Collections.Generic.IEnumerable{``0})">

+            <summary>

+            Returns a collection of tokens that contains the descendants of every token in the source collection.

+            </summary>

+            <typeparam name="T">The type of the objects in source, constrained to <see cref="T:Newtonsoft.Json.Linq.JContainer"/>.</typeparam>

+            <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the source collection.</param>

+            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the descendants of every node in the source collection.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.Extensions.Properties(System.Collections.Generic.IEnumerable{Newtonsoft.Json.Linq.JObject})">

+            <summary>

+            Returns a collection of child properties of every object in the source collection.

+            </summary>

+            <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JObject"/> that contains the source collection.</param>

+            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JProperty"/> that contains the properties of every object in the source collection.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.Extensions.Values(System.Collections.Generic.IEnumerable{Newtonsoft.Json.Linq.JToken},System.Object)">

+            <summary>

+            Returns a collection of child values of every object in the source collection with the given key.

+            </summary>

+            <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the source collection.</param>

+            <param name="key">The token key.</param>

+            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the values of every node in the source collection with the given key.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.Extensions.Values(System.Collections.Generic.IEnumerable{Newtonsoft.Json.Linq.JToken})">

+            <summary>

+            Returns a collection of child values of every object in the source collection.

+            </summary>

+            <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the source collection.</param>

+            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the values of every node in the source collection.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.Extensions.Values``1(System.Collections.Generic.IEnumerable{Newtonsoft.Json.Linq.JToken},System.Object)">

+            <summary>

+            Returns a collection of converted child values of every object in the source collection with the given key.

+            </summary>

+            <typeparam name="U">The type to convert the values to.</typeparam>

+            <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the source collection.</param>

+            <param name="key">The token key.</param>

+            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains the converted values of every node in the source collection with the given key.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.Extensions.Values``1(System.Collections.Generic.IEnumerable{Newtonsoft.Json.Linq.JToken})">

+            <summary>

+            Returns a collection of converted child values of every object in the source collection.

+            </summary>

+            <typeparam name="U">The type to convert the values to.</typeparam>

+            <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the source collection.</param>

+            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains the converted values of every node in the source collection.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.Extensions.Value``1(System.Collections.Generic.IEnumerable{Newtonsoft.Json.Linq.JToken})">

+            <summary>

+            Converts the value.

+            </summary>

+            <typeparam name="U">The type to convert the value to.</typeparam>

+            <param name="value">A <see cref="T:Newtonsoft.Json.Linq.JToken"/> cast as a <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/>.</param>

+            <returns>A converted value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.Extensions.Value``2(System.Collections.Generic.IEnumerable{``0})">

+            <summary>

+            Converts the value.

+            </summary>

+            <typeparam name="T">The source collection type.</typeparam>

+            <typeparam name="U">The type to convert the value to.</typeparam>

+            <param name="value">A <see cref="T:Newtonsoft.Json.Linq.JToken"/> cast as a <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/>.</param>

+            <returns>A converted value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.Extensions.Children``1(System.Collections.Generic.IEnumerable{``0})">

+            <summary>

+            Returns a collection of child tokens of every array in the source collection.

+            </summary>

+            <typeparam name="T">The source collection type.</typeparam>

+            <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the source collection.</param>

+            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the values of every node in the source collection.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.Extensions.Children``2(System.Collections.Generic.IEnumerable{``0})">

+            <summary>

+            Returns a collection of converted child tokens of every array in the source collection.

+            </summary>

+            <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the source collection.</param>

+            <typeparam name="U">The type to convert the values to.</typeparam>

+            <typeparam name="T">The source collection type.</typeparam>

+            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains the converted values of every node in the source collection.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.Extensions.AsJEnumerable(System.Collections.Generic.IEnumerable{Newtonsoft.Json.Linq.JToken})">

+            <summary>

+            Returns the input typed as <see cref="T:Newtonsoft.Json.Linq.IJEnumerable`1"/>.

+            </summary>

+            <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the source collection.</param>

+            <returns>The input typed as <see cref="T:Newtonsoft.Json.Linq.IJEnumerable`1"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.Extensions.AsJEnumerable``1(System.Collections.Generic.IEnumerable{``0})">

+            <summary>

+            Returns the input typed as <see cref="T:Newtonsoft.Json.Linq.IJEnumerable`1"/>.

+            </summary>

+            <typeparam name="T">The source collection type.</typeparam>

+            <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> that contains the source collection.</param>

+            <returns>The input typed as <see cref="T:Newtonsoft.Json.Linq.IJEnumerable`1"/>.</returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.JConstructor">

+            <summary>

+            Represents a JSON constructor.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.JContainer">

+            <summary>

+            Represents a token that can contain other tokens.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JContainer.OnAddingNew(System.ComponentModel.AddingNewEventArgs)">

+            <summary>

+            Raises the <see cref="E:Newtonsoft.Json.Linq.JContainer.AddingNew"/> event.

+            </summary>

+            <param name="e">The <see cref="T:System.ComponentModel.AddingNewEventArgs"/> instance containing the event data.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JContainer.OnListChanged(System.ComponentModel.ListChangedEventArgs)">

+            <summary>

+            Raises the <see cref="E:Newtonsoft.Json.Linq.JContainer.ListChanged"/> event.

+            </summary>

+            <param name="e">The <see cref="T:System.ComponentModel.ListChangedEventArgs"/> instance containing the event data.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JContainer.Children">

+            <summary>

+            Returns a collection of the child tokens of this token, in document order.

+            </summary>

+            <returns>

+            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> containing the child tokens of this <see cref="T:Newtonsoft.Json.Linq.JToken"/>, in document order.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JContainer.Values``1">

+            <summary>

+            Returns a collection of the child values of this token, in document order.

+            </summary>

+            <typeparam name="T">The type to convert the values to.</typeparam>

+            <returns>

+            A <see cref="T:System.Collections.Generic.IEnumerable`1"/> containing the child values of this <see cref="T:Newtonsoft.Json.Linq.JToken"/>, in document order.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JContainer.Descendants">

+            <summary>

+            Returns a collection of the descendant tokens for this token in document order.

+            </summary>

+            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> containing the descendant tokens of the <see cref="T:Newtonsoft.Json.Linq.JToken"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JContainer.Add(System.Object)">

+            <summary>

+            Adds the specified content as children of this <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="content">The content to be added.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JContainer.AddFirst(System.Object)">

+            <summary>

+            Adds the specified content as the first children of this <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="content">The content to be added.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JContainer.CreateWriter">

+            <summary>

+            Creates an <see cref="T:Newtonsoft.Json.JsonWriter"/> that can be used to add tokens to the <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <returns>An <see cref="T:Newtonsoft.Json.JsonWriter"/> that is ready to have content written to it.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JContainer.ReplaceAll(System.Object)">

+            <summary>

+            Replaces the children nodes of this token with the specified content.

+            </summary>

+            <param name="content">The content.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JContainer.RemoveAll">

+            <summary>

+            Removes the child nodes from this token.

+            </summary>

+        </member>

+        <member name="E:Newtonsoft.Json.Linq.JContainer.ListChanged">

+            <summary>

+            Occurs when the list changes or an item in the list changes.

+            </summary>

+        </member>

+        <member name="E:Newtonsoft.Json.Linq.JContainer.AddingNew">

+            <summary>

+            Occurs before an item is added to the collection.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JContainer.HasValues">

+            <summary>

+            Gets a value indicating whether this token has childen tokens.

+            </summary>

+            <value>

+                <c>true</c> if this token has child values; otherwise, <c>false</c>.

+            </value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JContainer.First">

+            <summary>

+            Get the first child token of this token.

+            </summary>

+            <value>

+            A <see cref="T:Newtonsoft.Json.Linq.JToken"/> containing the first child token of the <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JContainer.Last">

+            <summary>

+            Get the last child token of this token.

+            </summary>

+            <value>

+            A <see cref="T:Newtonsoft.Json.Linq.JToken"/> containing the last child token of the <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </value>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JConstructor.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JConstructor"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JConstructor.#ctor(Newtonsoft.Json.Linq.JConstructor)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JConstructor"/> class from another <see cref="T:Newtonsoft.Json.Linq.JConstructor"/> object.

+            </summary>

+            <param name="other">A <see cref="T:Newtonsoft.Json.Linq.JConstructor"/> object to copy from.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JConstructor.#ctor(System.String,System.Object[])">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JConstructor"/> class with the specified name and content.

+            </summary>

+            <param name="name">The constructor name.</param>

+            <param name="content">The contents of the constructor.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JConstructor.#ctor(System.String,System.Object)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JConstructor"/> class with the specified name and content.

+            </summary>

+            <param name="name">The constructor name.</param>

+            <param name="content">The contents of the constructor.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JConstructor.#ctor(System.String)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JConstructor"/> class with the specified name.

+            </summary>

+            <param name="name">The constructor name.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JConstructor.WriteTo(Newtonsoft.Json.JsonWriter,Newtonsoft.Json.JsonConverter[])">

+            <summary>

+            Writes this token to a <see cref="T:Newtonsoft.Json.JsonWriter"/>.

+            </summary>

+            <param name="writer">A <see cref="T:Newtonsoft.Json.JsonWriter"/> into which this method will write.</param>

+            <param name="converters">A collection of <see cref="T:Newtonsoft.Json.JsonConverter"/> which will be used when writing the token.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JConstructor.Load(Newtonsoft.Json.JsonReader)">

+            <summary>

+            Loads an <see cref="T:Newtonsoft.Json.Linq.JConstructor"/> from a <see cref="T:Newtonsoft.Json.JsonReader"/>. 

+            </summary>

+            <param name="reader">A <see cref="T:Newtonsoft.Json.JsonReader"/> that will be read for the content of the <see cref="T:Newtonsoft.Json.Linq.JConstructor"/>.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JConstructor"/> that contains the JSON that was read from the specified <see cref="T:Newtonsoft.Json.JsonReader"/>.</returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JConstructor.Name">

+            <summary>

+            Gets or sets the name of this constructor.

+            </summary>

+            <value>The constructor name.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JConstructor.Type">

+            <summary>

+            Gets the node type for this <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <value>The type.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JConstructor.Item(System.Object)">

+            <summary>

+            Gets the <see cref="T:Newtonsoft.Json.Linq.JToken"/> with the specified key.

+            </summary>

+            <value>The <see cref="T:Newtonsoft.Json.Linq.JToken"/> with the specified key.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.JEnumerable`1">

+            <summary>

+            Represents a collection of <see cref="T:Newtonsoft.Json.Linq.JToken"/> objects.

+            </summary>

+            <typeparam name="T">The type of token</typeparam>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JEnumerable`1.Empty">

+            <summary>

+            An empty collection of <see cref="T:Newtonsoft.Json.Linq.JToken"/> objects.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JEnumerable`1.#ctor(System.Collections.Generic.IEnumerable{`0})">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JEnumerable`1"/> struct.

+            </summary>

+            <param name="enumerable">The enumerable.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JEnumerable`1.GetEnumerator">

+            <summary>

+            Returns an enumerator that iterates through the collection.

+            </summary>

+            <returns>

+            A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JEnumerable`1.System#Collections#IEnumerable#GetEnumerator">

+            <summary>

+            Returns an enumerator that iterates through a collection.

+            </summary>

+            <returns>

+            An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JEnumerable`1.Equals(System.Object)">

+            <summary>

+            Determines whether the specified <see cref="T:System.Object"/> is equal to this instance.

+            </summary>

+            <param name="obj">The <see cref="T:System.Object"/> to compare with this instance.</param>

+            <returns>

+                <c>true</c> if the specified <see cref="T:System.Object"/> is equal to this instance; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JEnumerable`1.GetHashCode">

+            <summary>

+            Returns a hash code for this instance.

+            </summary>

+            <returns>

+            A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 

+            </returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JEnumerable`1.Item(System.Object)">

+            <summary>

+            Gets the <see cref="T:Newtonsoft.Json.Linq.IJEnumerable`1"/> with the specified key.

+            </summary>

+            <value></value>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.JObject">

+            <summary>

+            Represents a JSON object.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JObject"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.#ctor(Newtonsoft.Json.Linq.JObject)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JObject"/> class from another <see cref="T:Newtonsoft.Json.Linq.JObject"/> object.

+            </summary>

+            <param name="other">A <see cref="T:Newtonsoft.Json.Linq.JObject"/> object to copy from.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.#ctor(System.Object[])">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JObject"/> class with the specified content.

+            </summary>

+            <param name="content">The contents of the object.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.#ctor(System.Object)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JObject"/> class with the specified content.

+            </summary>

+            <param name="content">The contents of the object.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.Properties">

+            <summary>

+            Gets an <see cref="T:System.Collections.Generic.IEnumerable`1"/> of this object's properties.

+            </summary>

+            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of this object's properties.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.Property(System.String)">

+            <summary>

+            Gets a <see cref="T:Newtonsoft.Json.Linq.JProperty"/> the specified name.

+            </summary>

+            <param name="name">The property name.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JProperty"/> with the specified name or null.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.PropertyValues">

+            <summary>

+            Gets an <see cref="T:Newtonsoft.Json.Linq.JEnumerable`1"/> of this object's property values.

+            </summary>

+            <returns>An <see cref="T:Newtonsoft.Json.Linq.JEnumerable`1"/> of this object's property values.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.Load(Newtonsoft.Json.JsonReader)">

+            <summary>

+            Loads an <see cref="T:Newtonsoft.Json.Linq.JObject"/> from a <see cref="T:Newtonsoft.Json.JsonReader"/>. 

+            </summary>

+            <param name="reader">A <see cref="T:Newtonsoft.Json.JsonReader"/> that will be read for the content of the <see cref="T:Newtonsoft.Json.Linq.JObject"/>.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JObject"/> that contains the JSON that was read from the specified <see cref="T:Newtonsoft.Json.JsonReader"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.Parse(System.String)">

+            <summary>

+            Load a <see cref="T:Newtonsoft.Json.Linq.JObject"/> from a string that contains JSON.

+            </summary>

+            <param name="json">A <see cref="T:System.String"/> that contains JSON.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JObject"/> populated from the string that contains JSON.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.FromObject(System.Object)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Linq.JObject"/> from an object.

+            </summary>

+            <param name="o">The object that will be used to create <see cref="T:Newtonsoft.Json.Linq.JObject"/>.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JObject"/> with the values of the specified object</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.FromObject(System.Object,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Linq.JArray"/> from an object.

+            </summary>

+            <param name="o">The object that will be used to create <see cref="T:Newtonsoft.Json.Linq.JArray"/>.</param>

+            <param name="jsonSerializer">The <see cref="T:Newtonsoft.Json.JsonSerializer"/> that will be used to read the object.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JArray"/> with the values of the specified object</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.WriteTo(Newtonsoft.Json.JsonWriter,Newtonsoft.Json.JsonConverter[])">

+            <summary>

+            Writes this token to a <see cref="T:Newtonsoft.Json.JsonWriter"/>.

+            </summary>

+            <param name="writer">A <see cref="T:Newtonsoft.Json.JsonWriter"/> into which this method will write.</param>

+            <param name="converters">A collection of <see cref="T:Newtonsoft.Json.JsonConverter"/> which will be used when writing the token.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.Add(System.String,Newtonsoft.Json.Linq.JToken)">

+            <summary>

+            Adds the specified property name.

+            </summary>

+            <param name="propertyName">Name of the property.</param>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.Remove(System.String)">

+            <summary>

+            Removes the property with the specified name.

+            </summary>

+            <param name="propertyName">Name of the property.</param>

+            <returns>true if item was successfully removed; otherwise, false.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.TryGetValue(System.String,Newtonsoft.Json.Linq.JToken@)">

+            <summary>

+            Tries the get value.

+            </summary>

+            <param name="propertyName">Name of the property.</param>

+            <param name="value">The value.</param>

+            <returns>true if a value was successfully retrieved; otherwise, false.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.GetEnumerator">

+            <summary>

+            Returns an enumerator that iterates through the collection.

+            </summary>

+            <returns>

+            A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JObject.OnPropertyChanged(System.String)">

+            <summary>

+            Raises the <see cref="E:Newtonsoft.Json.Linq.JObject.PropertyChanged"/> event with the provided arguments.

+            </summary>

+            <param name="propertyName">Name of the property.</param>

+        </member>

+        <member name="E:Newtonsoft.Json.Linq.JObject.PropertyChanged">

+            <summary>

+            Occurs when a property value changes.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JObject.Type">

+            <summary>

+            Gets the node type for this <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <value>The type.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JObject.Item(System.Object)">

+            <summary>

+            Gets the <see cref="T:Newtonsoft.Json.Linq.JToken"/> with the specified key.

+            </summary>

+            <value>The <see cref="T:Newtonsoft.Json.Linq.JToken"/> with the specified key.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JObject.Item(System.String)">

+            <summary>

+            Gets or sets the <see cref="T:Newtonsoft.Json.Linq.JToken"/> with the specified property name.

+            </summary>

+            <value></value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JObject.Count">

+            <summary>

+            Gets the number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>.

+            </summary>

+            <value></value>

+            <returns>The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>.</returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.JArray">

+            <summary>

+            Represents a JSON array.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JArray"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.#ctor(Newtonsoft.Json.Linq.JArray)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JArray"/> class from another <see cref="T:Newtonsoft.Json.Linq.JArray"/> object.

+            </summary>

+            <param name="other">A <see cref="T:Newtonsoft.Json.Linq.JArray"/> object to copy from.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.#ctor(System.Object[])">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JArray"/> class with the specified content.

+            </summary>

+            <param name="content">The contents of the array.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.#ctor(System.Object)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JArray"/> class with the specified content.

+            </summary>

+            <param name="content">The contents of the array.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.Load(Newtonsoft.Json.JsonReader)">

+            <summary>

+            Loads an <see cref="T:Newtonsoft.Json.Linq.JArray"/> from a <see cref="T:Newtonsoft.Json.JsonReader"/>. 

+            </summary>

+            <param name="reader">A <see cref="T:Newtonsoft.Json.JsonReader"/> that will be read for the content of the <see cref="T:Newtonsoft.Json.Linq.JArray"/>.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JArray"/> that contains the JSON that was read from the specified <see cref="T:Newtonsoft.Json.JsonReader"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.Parse(System.String)">

+            <summary>

+            Load a <see cref="T:Newtonsoft.Json.Linq.JArray"/> from a string that contains JSON.

+            </summary>

+            <param name="json">A <see cref="T:System.String"/> that contains JSON.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JArray"/> populated from the string that contains JSON.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.FromObject(System.Object)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Linq.JArray"/> from an object.

+            </summary>

+            <param name="o">The object that will be used to create <see cref="T:Newtonsoft.Json.Linq.JArray"/>.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JArray"/> with the values of the specified object</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.FromObject(System.Object,Newtonsoft.Json.JsonSerializer)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Linq.JArray"/> from an object.

+            </summary>

+            <param name="o">The object that will be used to create <see cref="T:Newtonsoft.Json.Linq.JArray"/>.</param>

+            <param name="jsonSerializer">The <see cref="T:Newtonsoft.Json.JsonSerializer"/> that will be used to read the object.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JArray"/> with the values of the specified object</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.WriteTo(Newtonsoft.Json.JsonWriter,Newtonsoft.Json.JsonConverter[])">

+            <summary>

+            Writes this token to a <see cref="T:Newtonsoft.Json.JsonWriter"/>.

+            </summary>

+            <param name="writer">A <see cref="T:Newtonsoft.Json.JsonWriter"/> into which this method will write.</param>

+            <param name="converters">A collection of <see cref="T:Newtonsoft.Json.JsonConverter"/> which will be used when writing the token.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.IndexOf(Newtonsoft.Json.Linq.JToken)">

+            <summary>

+            Determines the index of a specific item in the <see cref="T:System.Collections.Generic.IList`1"/>.

+            </summary>

+            <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.IList`1"/>.</param>

+            <returns>

+            The index of <paramref name="item"/> if found in the list; otherwise, -1.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.Insert(System.Int32,Newtonsoft.Json.Linq.JToken)">

+            <summary>

+            Inserts an item to the <see cref="T:System.Collections.Generic.IList`1"/> at the specified index.

+            </summary>

+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>

+            <param name="item">The object to insert into the <see cref="T:System.Collections.Generic.IList`1"/>.</param>

+            <exception cref="T:System.ArgumentOutOfRangeException">

+                <paramref name="index"/> is not a valid index in the <see cref="T:System.Collections.Generic.IList`1"/>.</exception>

+            <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.IList`1"/> is read-only.</exception>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.RemoveAt(System.Int32)">

+            <summary>

+            Removes the <see cref="T:System.Collections.Generic.IList`1"/> item at the specified index.

+            </summary>

+            <param name="index">The zero-based index of the item to remove.</param>

+            <exception cref="T:System.ArgumentOutOfRangeException">

+                <paramref name="index"/> is not a valid index in the <see cref="T:System.Collections.Generic.IList`1"/>.</exception>

+            <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.IList`1"/> is read-only.</exception>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.Add(Newtonsoft.Json.Linq.JToken)">

+            <summary>

+            Adds an item to the <see cref="T:System.Collections.Generic.ICollection`1"/>.

+            </summary>

+            <param name="item">The object to add to the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param>

+            <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only.</exception>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.Clear">

+            <summary>

+            Removes all items from the <see cref="T:System.Collections.Generic.ICollection`1"/>.

+            </summary>

+            <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only. </exception>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.Contains(Newtonsoft.Json.Linq.JToken)">

+            <summary>

+            Determines whether the <see cref="T:System.Collections.Generic.ICollection`1"/> contains a specific value.

+            </summary>

+            <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param>

+            <returns>

+            true if <paramref name="item"/> is found in the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JArray.Remove(Newtonsoft.Json.Linq.JToken)">

+            <summary>

+            Removes the first occurrence of a specific object from the <see cref="T:System.Collections.Generic.ICollection`1"/>.

+            </summary>

+            <param name="item">The object to remove from the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param>

+            <returns>

+            true if <paramref name="item"/> was successfully removed from the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. This method also returns false if <paramref name="item"/> is not found in the original <see cref="T:System.Collections.Generic.ICollection`1"/>.

+            </returns>

+            <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only.</exception>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JArray.Type">

+            <summary>

+            Gets the node type for this <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <value>The type.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JArray.Item(System.Object)">

+            <summary>

+            Gets the <see cref="T:Newtonsoft.Json.Linq.JToken"/> with the specified key.

+            </summary>

+            <value>The <see cref="T:Newtonsoft.Json.Linq.JToken"/> with the specified key.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JArray.Item(System.Int32)">

+            <summary>

+            Gets or sets the <see cref="T:Newtonsoft.Json.Linq.JToken"/> at the specified index.

+            </summary>

+            <value></value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JArray.Count">

+            <summary>

+            Gets the number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>.

+            </summary>

+            <value></value>

+            <returns>The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>.</returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.JTokenReader">

+            <summary>

+            Represents a reader that provides fast, non-cached, forward-only access to serialized Json data.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenReader.#ctor(Newtonsoft.Json.Linq.JToken)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JTokenReader"/> class.

+            </summary>

+            <param name="token">The token to read from.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenReader.ReadAsBytes">

+            <summary>

+            Reads the next JSON token from the stream as a <see cref="T:Byte[]"/>.

+            </summary>

+            <returns>

+            A <see cref="T:Byte[]"/> or a null reference if the next JSON token is null.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JTokenReader.Read">

+            <summary>

+            Reads the next JSON token from the stream.

+            </summary>

+            <returns>

+            true if the next token was read successfully; false if there are no more tokens to read.

+            </returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.JProperty">

+            <summary>

+            Represents a JSON property.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JProperty.#ctor(Newtonsoft.Json.Linq.JProperty)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JProperty"/> class from another <see cref="T:Newtonsoft.Json.Linq.JProperty"/> object.

+            </summary>

+            <param name="other">A <see cref="T:Newtonsoft.Json.Linq.JProperty"/> object to copy from.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JProperty.Children">

+            <summary>

+            Returns a collection of the child tokens of this token, in document order.

+            </summary>

+            <returns>

+            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of <see cref="T:Newtonsoft.Json.Linq.JToken"/> containing the child tokens of this <see cref="T:Newtonsoft.Json.Linq.JToken"/>, in document order.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JProperty.#ctor(System.String,System.Object[])">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JProperty"/> class.

+            </summary>

+            <param name="name">The property name.</param>

+            <param name="content">The property content.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JProperty.#ctor(System.String,System.Object)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Linq.JProperty"/> class.

+            </summary>

+            <param name="name">The property name.</param>

+            <param name="content">The property content.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JProperty.WriteTo(Newtonsoft.Json.JsonWriter,Newtonsoft.Json.JsonConverter[])">

+            <summary>

+            Writes this token to a <see cref="T:Newtonsoft.Json.JsonWriter"/>.

+            </summary>

+            <param name="writer">A <see cref="T:Newtonsoft.Json.JsonWriter"/> into which this method will write.</param>

+            <param name="converters">A collection of <see cref="T:Newtonsoft.Json.JsonConverter"/> which will be used when writing the token.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Linq.JProperty.Load(Newtonsoft.Json.JsonReader)">

+            <summary>

+            Loads an <see cref="T:Newtonsoft.Json.Linq.JProperty"/> from a <see cref="T:Newtonsoft.Json.JsonReader"/>. 

+            </summary>

+            <param name="reader">A <see cref="T:Newtonsoft.Json.JsonReader"/> that will be read for the content of the <see cref="T:Newtonsoft.Json.Linq.JProperty"/>.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Linq.JProperty"/> that contains the JSON that was read from the specified <see cref="T:Newtonsoft.Json.JsonReader"/>.</returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JProperty.Name">

+            <summary>

+            Gets the property name.

+            </summary>

+            <value>The property name.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JProperty.Value">

+            <summary>

+            Gets or sets the property value.

+            </summary>

+            <value>The property value.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Linq.JProperty.Type">

+            <summary>

+            Gets the node type for this <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <value>The type.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Linq.JTokenType">

+            <summary>

+            Specifies the type of token.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.None">

+            <summary>

+            No token type has been set.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.Object">

+            <summary>

+            A JSON object.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.Array">

+            <summary>

+            A JSON array.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.Constructor">

+            <summary>

+            A JSON constructor.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.Property">

+            <summary>

+            A JSON object property.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.Comment">

+            <summary>

+            A comment.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.Integer">

+            <summary>

+            An integer value.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.Float">

+            <summary>

+            A float value.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.String">

+            <summary>

+            A string value.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.Boolean">

+            <summary>

+            A boolean value.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.Null">

+            <summary>

+            A null value.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.Undefined">

+            <summary>

+            An undefined value.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.Date">

+            <summary>

+            A date value.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.Raw">

+            <summary>

+            A raw JSON value.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Linq.JTokenType.Bytes">

+            <summary>

+            A collection of bytes value.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Schema.Extensions">

+            <summary>

+            Contains the JSON schema extension methods.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.Extensions.IsValid(Newtonsoft.Json.Linq.JToken,Newtonsoft.Json.Schema.JsonSchema)">

+            <summary>

+            Determines whether the <see cref="T:Newtonsoft.Json.Linq.JToken"/> is valid.

+            </summary>

+            <param name="source">The source <see cref="T:Newtonsoft.Json.Linq.JToken"/> to test.</param>

+            <param name="schema">The schema to test with.</param>

+            <returns>

+                <c>true</c> if the specified <see cref="T:Newtonsoft.Json.Linq.JToken"/> is valid; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.Extensions.Validate(Newtonsoft.Json.Linq.JToken,Newtonsoft.Json.Schema.JsonSchema)">

+            <summary>

+            Validates the specified <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="source">The source <see cref="T:Newtonsoft.Json.Linq.JToken"/> to test.</param>

+            <param name="schema">The schema to test with.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.Extensions.Validate(Newtonsoft.Json.Linq.JToken,Newtonsoft.Json.Schema.JsonSchema,Newtonsoft.Json.Schema.ValidationEventHandler)">

+            <summary>

+            Validates the specified <see cref="T:Newtonsoft.Json.Linq.JToken"/>.

+            </summary>

+            <param name="source">The source <see cref="T:Newtonsoft.Json.Linq.JToken"/> to test.</param>

+            <param name="schema">The schema to test with.</param>

+            <param name="validationEventHandler">The validation event handler.</param>

+        </member>

+        <member name="T:Newtonsoft.Json.Schema.JsonSchemaException">

+            <summary>

+            Returns detailed information about the schema exception.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchemaException.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Schema.JsonSchemaException"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchemaException.#ctor(System.String)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Schema.JsonSchemaException"/> class

+            with a specified error message.

+            </summary>

+            <param name="message">The error message that explains the reason for the exception.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchemaException.#ctor(System.String,System.Exception)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Schema.JsonSchemaException"/> class

+            with a specified error message and a reference to the inner exception that is the cause of this exception.

+            </summary>

+            <param name="message">The error message that explains the reason for the exception.</param>

+            <param name="innerException">The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified.</param>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchemaException.LineNumber">

+            <summary>

+            Gets the line number indicating where the error occurred.

+            </summary>

+            <value>The line number indicating where the error occurred.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchemaException.LinePosition">

+            <summary>

+            Gets the line position indicating where the error occurred.

+            </summary>

+            <value>The line position indicating where the error occurred.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Schema.JsonSchemaResolver">

+            <summary>

+            Resolves <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> from an id.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchemaResolver.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Schema.JsonSchemaResolver"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchemaResolver.GetSchema(System.String)">

+            <summary>

+            Gets a <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> for the specified id.

+            </summary>

+            <param name="id">The id.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> for the specified id.</returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchemaResolver.LoadedSchemas">

+            <summary>

+            Gets or sets the loaded schemas.

+            </summary>

+            <value>The loaded schemas.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Schema.UndefinedSchemaIdHandling">

+            <summary>

+            Specifies undefined schema Id handling options for the <see cref="T:Newtonsoft.Json.Schema.JsonSchemaGenerator"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Schema.UndefinedSchemaIdHandling.None">

+            <summary>

+            Do not infer a schema Id.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Schema.UndefinedSchemaIdHandling.UseTypeName">

+            <summary>

+            Use the .NET type name as the schema Id.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Schema.UndefinedSchemaIdHandling.UseAssemblyQualifiedName">

+            <summary>

+            Use the assembly qualified .NET type name as the schema Id.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Schema.ValidationEventArgs">

+            <summary>

+            Returns detailed information related to the <see cref="T:Newtonsoft.Json.Schema.ValidationEventHandler"/>.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.ValidationEventArgs.Exception">

+            <summary>

+            Gets the <see cref="T:Newtonsoft.Json.Schema.JsonSchemaException"/> associated with the validation event.

+            </summary>

+            <value>The JsonSchemaException associated with the validation event.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.ValidationEventArgs.Message">

+            <summary>

+            Gets the text description corresponding to the validation event.

+            </summary>

+            <value>The text description.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Schema.ValidationEventHandler">

+            <summary>

+            Represents the callback method that will handle JSON schema validation events and the <see cref="T:Newtonsoft.Json.Schema.ValidationEventArgs"/>.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver">

+            <summary>

+            Resolves member mappings for a type, camel casing property names.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.DefaultContractResolver">

+            <summary>

+            Used by <see cref="T:Newtonsoft.Json.JsonSerializer"/> to resolves a <see cref="T:Newtonsoft.Json.Serialization.JsonContract"/> for a given <see cref="T:System.Type"/>.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.IContractResolver">

+            <summary>

+            Used by <see cref="T:Newtonsoft.Json.JsonSerializer"/> to resolves a <see cref="T:Newtonsoft.Json.Serialization.JsonContract"/> for a given <see cref="T:System.Type"/>.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.IContractResolver.ResolveContract(System.Type)">

+            <summary>

+            Resolves the contract for a given type.

+            </summary>

+            <param name="type">The type to resolve a contract for.</param>

+            <returns>The contract for a given type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultContractResolver.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Serialization.DefaultContractResolver"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultContractResolver.ResolveContract(System.Type)">

+            <summary>

+            Resolves the contract for a given type.

+            </summary>

+            <param name="type">The type to resolve a contract for.</param>

+            <returns>The contract for a given type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultContractResolver.GetSerializableMembers(System.Type)">

+            <summary>

+            Gets the serializable members for the type.

+            </summary>

+            <param name="objectType">The type to get serializable members for.</param>

+            <returns>The serializable members for the type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultContractResolver.CreateObjectContract(System.Type)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Serialization.JsonObjectContract"/> for the given type.

+            </summary>

+            <param name="objectType">Type of the object.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Serialization.JsonObjectContract"/> for the given type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultContractResolver.ResolveContractConverter(System.Type)">

+            <summary>

+            Resolves the default <see cref="T:Newtonsoft.Json.JsonConverter"/> for the contract.

+            </summary>

+            <param name="objectType">Type of the object.</param>

+            <returns></returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultContractResolver.CreateDictionaryContract(System.Type)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Serialization.JsonDictionaryContract"/> for the given type.

+            </summary>

+            <param name="objectType">Type of the object.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Serialization.JsonDictionaryContract"/> for the given type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultContractResolver.CreateArrayContract(System.Type)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Serialization.JsonArrayContract"/> for the given type.

+            </summary>

+            <param name="objectType">Type of the object.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Serialization.JsonArrayContract"/> for the given type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultContractResolver.CreatePrimitiveContract(System.Type)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Serialization.JsonPrimitiveContract"/> for the given type.

+            </summary>

+            <param name="objectType">Type of the object.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Serialization.JsonPrimitiveContract"/> for the given type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultContractResolver.CreateLinqContract(System.Type)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Serialization.JsonLinqContract"/> for the given type.

+            </summary>

+            <param name="objectType">Type of the object.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Serialization.JsonLinqContract"/> for the given type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultContractResolver.CreateProperties(Newtonsoft.Json.Serialization.JsonObjectContract)">

+            <summary>

+            Creates properties for the given <see cref="T:Newtonsoft.Json.Serialization.JsonObjectContract"/>.

+            </summary>

+            <param name="contract">The contract to create properties for.</param>

+            <returns>Properties for the given <see cref="T:Newtonsoft.Json.Serialization.JsonObjectContract"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultContractResolver.CreateMemberValueProvider(System.Reflection.MemberInfo)">

+            <summary>

+            Creates the <see cref="T:Newtonsoft.Json.Serialization.IValueProvider"/> used by the serializer to get and set values from a member.

+            </summary>

+            <param name="member">The member.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Serialization.IValueProvider"/> used by the serializer to get and set values from a member.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultContractResolver.CreateProperty(Newtonsoft.Json.Serialization.JsonObjectContract,System.Reflection.MemberInfo)">

+            <summary>

+            Creates a <see cref="T:Newtonsoft.Json.Serialization.JsonProperty"/> for the given <see cref="T:System.Reflection.MemberInfo"/>.

+            </summary>

+            <param name="contract">The member's declaring types <see cref="T:Newtonsoft.Json.Serialization.JsonObjectContract"/>.</param>

+            <param name="member">The member to create a <see cref="T:Newtonsoft.Json.Serialization.JsonProperty"/> for.</param>

+            <returns>A created <see cref="T:Newtonsoft.Json.Serialization.JsonProperty"/> for the given <see cref="T:System.Reflection.MemberInfo"/>.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultContractResolver.ResolvePropertyName(System.String)">

+            <summary>

+            Resolves the name of the property.

+            </summary>

+            <param name="propertyName">Name of the property.</param>

+            <returns>Name of the property.</returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.DefaultContractResolver.DefaultMembersSearchFlags">

+            <summary>

+            Gets or sets the default members search flags.

+            </summary>

+            <value>The default members search flags.</value>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver.ResolvePropertyName(System.String)">

+            <summary>

+            Resolves the name of the property.

+            </summary>

+            <param name="propertyName">Name of the property.</param>

+            <returns>The property name camel cased.</returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.DefaultSerializationBinder">

+            <summary>

+            The default serialization binder used when resolving and loading classes from type names.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DefaultSerializationBinder.BindToType(System.String,System.String)">

+            <summary>

+            When overridden in a derived class, controls the binding of a serialized object to a type.

+            </summary>

+            <param name="assemblyName">Specifies the <see cref="T:System.Reflection.Assembly"/> name of the serialized object.</param>

+            <param name="typeName">Specifies the <see cref="T:System.Type"/> name of the serialized object.</param>

+            <returns>

+            The type of the object the formatter creates a new instance of.

+            </returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.DynamicValueProvider">

+            <summary>

+            Get and set values for a <see cref="T:System.Reflection.MemberInfo"/> using dynamic methods.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.IValueProvider">

+            <summary>

+            Provides methods to get and set values.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.IValueProvider.SetValue(System.Object,System.Object)">

+            <summary>

+            Sets the value.

+            </summary>

+            <param name="target">The target to set the value on.</param>

+            <param name="value">The value to set on the target.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.IValueProvider.GetValue(System.Object)">

+            <summary>

+            Gets the value.

+            </summary>

+            <param name="target">The target to get the value from.</param>

+            <returns>The value.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DynamicValueProvider.#ctor(System.Reflection.MemberInfo)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Serialization.DynamicValueProvider"/> class.

+            </summary>

+            <param name="memberInfo">The member info.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DynamicValueProvider.SetValue(System.Object,System.Object)">

+            <summary>

+            Sets the value.

+            </summary>

+            <param name="target">The target to set the value on.</param>

+            <param name="value">The value to set on the target.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.DynamicValueProvider.GetValue(System.Object)">

+            <summary>

+            Gets the value.

+            </summary>

+            <param name="target">The target to get the value from.</param>

+            <returns>The value.</returns>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.ErrorContext">

+            <summary>

+            Provides information surrounding an error.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.ErrorContext.Error">

+            <summary>

+            Gets or sets the error.

+            </summary>

+            <value>The error.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.ErrorContext.OriginalObject">

+            <summary>

+            Gets the original object that caused the error.

+            </summary>

+            <value>The original object that caused the error.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.ErrorContext.Member">

+            <summary>

+            Gets the member that caused the error.

+            </summary>

+            <value>The member that caused the error.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.ErrorContext.Handled">

+            <summary>

+            Gets or sets a value indicating whether this <see cref="T:Newtonsoft.Json.Serialization.ErrorContext"/> is handled.

+            </summary>

+            <value><c>true</c> if handled; otherwise, <c>false</c>.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.ErrorEventArgs">

+            <summary>

+            Provides data for the Error event.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.ErrorEventArgs.#ctor(System.Object,Newtonsoft.Json.Serialization.ErrorContext)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Serialization.ErrorEventArgs"/> class.

+            </summary>

+            <param name="currentObject">The current object.</param>

+            <param name="errorContext">The error context.</param>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.ErrorEventArgs.CurrentObject">

+            <summary>

+            Gets the current object the error event is being raised against.

+            </summary>

+            <value>The current object the error event is being raised against.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.ErrorEventArgs.ErrorContext">

+            <summary>

+            Gets the error context.

+            </summary>

+            <value>The error context.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.JsonArrayContract">

+            <summary>

+            Contract details for a <see cref="T:System.Type"/> used by the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.JsonContract">

+            <summary>

+            Contract details for a <see cref="T:System.Type"/> used by the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonContract.UnderlyingType">

+            <summary>

+            Gets the underlying type for the contract.

+            </summary>

+            <value>The underlying type for the contract.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonContract.CreatedType">

+            <summary>

+            Gets or sets the type created during deserialization.

+            </summary>

+            <value>The type created during deserialization.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonContract.IsReference">

+            <summary>

+            Gets or sets whether this type contract is serialized as a reference.

+            </summary>

+            <value>Whether this type contract is serialized as a reference.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonContract.Converter">

+            <summary>

+            Gets or sets the default <see cref="T:Newtonsoft.Json.JsonConverter"/> for this contract.

+            </summary>

+            <value>The converter.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonContract.OnDeserialized">

+            <summary>

+            Gets or sets the method called immediately after deserialization of the object.

+            </summary>

+            <value>The method called immediately after deserialization of the object.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonContract.OnDeserializing">

+            <summary>

+            Gets or sets the method called during deserialization of the object.

+            </summary>

+            <value>The method called during deserialization of the object.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonContract.OnSerialized">

+            <summary>

+            Gets or sets the method called after serialization of the object graph.

+            </summary>

+            <value>The method called after serialization of the object graph.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonContract.OnSerializing">

+            <summary>

+            Gets or sets the method called before serialization of the object.

+            </summary>

+            <value>The method called before serialization of the object.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonContract.DefaultCreator">

+            <summary>

+            Gets or sets the default creator.

+            </summary>

+            <value>The default creator.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonContract.DefaultCreatorNonPublic">

+            <summary>

+            Gets or sets a value indicating whether [default creator non public].

+            </summary>

+            <value><c>true</c> if the default object creator is non-public; otherwise, <c>false</c>.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonContract.OnError">

+            <summary>

+            Gets or sets the method called when an error is thrown during the serialization of the object.

+            </summary>

+            <value>The method called when an error is thrown during the serialization of the object.</value>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.JsonArrayContract.#ctor(System.Type)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Serialization.JsonArrayContract"/> class.

+            </summary>

+            <param name="underlyingType">The underlying type for the contract.</param>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.JsonDictionaryContract">

+            <summary>

+            Contract details for a <see cref="T:System.Type"/> used by the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.JsonDictionaryContract.#ctor(System.Type)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Serialization.JsonDictionaryContract"/> class.

+            </summary>

+            <param name="underlyingType">The underlying type for the contract.</param>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.JsonLinqContract">

+            <summary>

+            Contract details for a <see cref="T:System.Type"/> used by the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.JsonLinqContract.#ctor(System.Type)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Serialization.JsonLinqContract"/> class.

+            </summary>

+            <param name="underlyingType">The underlying type for the contract.</param>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.JsonPrimitiveContract">

+            <summary>

+            Contract details for a <see cref="T:System.Type"/> used by the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.JsonPrimitiveContract.#ctor(System.Type)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Serialization.JsonPrimitiveContract"/> class.

+            </summary>

+            <param name="underlyingType">The underlying type for the contract.</param>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.JsonProperty">

+            <summary>

+            Maps a JSON property to a .NET member.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.PropertyName">

+            <summary>

+            Gets the name of the property.

+            </summary>

+            <value>The name of the property.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.ValueProvider">

+            <summary>

+            Gets the <see cref="T:Newtonsoft.Json.Serialization.IValueProvider"/> that will get and set the <see cref="T:Newtonsoft.Json.Serialization.JsonProperty"/> during serialization.

+            </summary>

+            <value>The <see cref="T:Newtonsoft.Json.Serialization.IValueProvider"/> that will get and set the <see cref="T:Newtonsoft.Json.Serialization.JsonProperty"/> during serialization.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.PropertyType">

+            <summary>

+            Gets or sets the type of the property.

+            </summary>

+            <value>The type of the property.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.Converter">

+            <summary>

+            Gets or sets the <see cref="T:Newtonsoft.Json.JsonConverter"/> for the property.

+            If set this converter takes presidence over the contract converter for the property type.

+            </summary>

+            <value>The converter.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.Ignored">

+            <summary>

+            Gets a value indicating whether this <see cref="T:Newtonsoft.Json.Serialization.JsonProperty"/> is ignored.

+            </summary>

+            <value><c>true</c> if ignored; otherwise, <c>false</c>.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.Readable">

+            <summary>

+            Gets a value indicating whether this <see cref="T:Newtonsoft.Json.Serialization.JsonProperty"/> is readable.

+            </summary>

+            <value><c>true</c> if readable; otherwise, <c>false</c>.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.Writable">

+            <summary>

+            Gets a value indicating whether this <see cref="T:Newtonsoft.Json.Serialization.JsonProperty"/> is writable.

+            </summary>

+            <value><c>true</c> if writable; otherwise, <c>false</c>.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.MemberConverter">

+            <summary>

+            Gets the member converter.

+            </summary>

+            <value>The member converter.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.DefaultValue">

+            <summary>

+            Gets the default value.

+            </summary>

+            <value>The default value.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.Required">

+            <summary>

+            Gets a value indicating whether this <see cref="T:Newtonsoft.Json.Serialization.JsonProperty"/> is required.

+            </summary>

+            <value>A value indicating whether this <see cref="T:Newtonsoft.Json.Serialization.JsonProperty"/> is required.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.IsReference">

+            <summary>

+            Gets a value indicating whether this property preserves object references.

+            </summary>

+            <value>

+                <c>true</c> if this instance is reference; otherwise, <c>false</c>.

+            </value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.NullValueHandling">

+            <summary>

+            Gets the property null value handling.

+            </summary>

+            <value>The null value handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.DefaultValueHandling">

+            <summary>

+            Gets the property default value handling.

+            </summary>

+            <value>The default value handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.ReferenceLoopHandling">

+            <summary>

+            Gets the property reference loop handling.

+            </summary>

+            <value>The reference loop handling.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonProperty.ObjectCreationHandling">

+            <summary>

+            Gets the property object creation handling.

+            </summary>

+            <value>The object creation handling.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.JsonPropertyCollection">

+            <summary>

+            A collection of <see cref="T:Newtonsoft.Json.Serialization.JsonProperty"/> objects.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.JsonPropertyCollection.#ctor(Newtonsoft.Json.Serialization.JsonObjectContract)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Serialization.JsonPropertyCollection"/> class.

+            </summary>

+            <param name="contract">The contract.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.JsonPropertyCollection.GetKeyForItem(Newtonsoft.Json.Serialization.JsonProperty)">

+            <summary>

+            When implemented in a derived class, extracts the key from the specified element.

+            </summary>

+            <param name="item">The element from which to extract the key.</param>

+            <returns>The key for the specified element.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.JsonPropertyCollection.AddProperty(Newtonsoft.Json.Serialization.JsonProperty)">

+            <summary>

+            Adds a <see cref="T:Newtonsoft.Json.Serialization.JsonProperty"/> object.

+            </summary>

+            <param name="property">The property to add to the collection.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.JsonPropertyCollection.GetClosestMatchProperty(System.String)">

+            <summary>

+            Gets the closest matching <see cref="T:Newtonsoft.Json.Serialization.JsonProperty"/> object.

+            First attempts to get an exact case match of propertyName and then

+            a case insensitive match.

+            </summary>

+            <param name="propertyName">Name of the property.</param>

+            <returns>A matching property if found.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.JsonPropertyCollection.GetProperty(System.String,System.StringComparison)">

+            <summary>

+            Gets a property by property name.

+            </summary>

+            <param name="propertyName">The name of the property to get.</param>

+            <param name="comparisonType">Type property name string comparison.</param>

+            <returns>A matching property if found.</returns>

+        </member>

+        <member name="T:Newtonsoft.Json.MissingMemberHandling">

+            <summary>

+            Specifies missing member handling options for the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.MissingMemberHandling.Ignore">

+            <summary>

+            Ignore a missing member and do not attempt to deserialize it.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.MissingMemberHandling.Error">

+            <summary>

+            Throw a <see cref="T:Newtonsoft.Json.JsonSerializationException"/> when a missing member is encountered during deserialization.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.NullValueHandling">

+            <summary>

+            Specifies null value handling options for the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.NullValueHandling.Include">

+            <summary>

+            Include null values when serializing and deserializing objects.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.NullValueHandling.Ignore">

+            <summary>

+            Ignore null values when serializing and deserializing objects.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.ReferenceLoopHandling">

+            <summary>

+            Specifies reference loop handling options for the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.ReferenceLoopHandling.Error">

+            <summary>

+            Throw a <see cref="T:Newtonsoft.Json.JsonSerializationException"/> when a loop is encountered.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.ReferenceLoopHandling.Ignore">

+            <summary>

+            Ignore loop references and do not serialize.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.ReferenceLoopHandling.Serialize">

+            <summary>

+            Serialize loop references.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Schema.JsonSchema">

+            <summary>

+            An in-memory representation of a JSON Schema.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchema.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> class.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchema.Read(Newtonsoft.Json.JsonReader)">

+            <summary>

+            Reads a <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> from the specified <see cref="T:Newtonsoft.Json.JsonReader"/>.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> containing the JSON Schema to read.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> object representing the JSON Schema.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchema.Read(Newtonsoft.Json.JsonReader,Newtonsoft.Json.Schema.JsonSchemaResolver)">

+            <summary>

+            Reads a <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> from the specified <see cref="T:Newtonsoft.Json.JsonReader"/>.

+            </summary>

+            <param name="reader">The <see cref="T:Newtonsoft.Json.JsonReader"/> containing the JSON Schema to read.</param>

+            <param name="resolver">The <see cref="T:Newtonsoft.Json.Schema.JsonSchemaResolver"/> to use when resolving schema references.</param>

+            <returns>The <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> object representing the JSON Schema.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchema.Parse(System.String)">

+            <summary>

+            Load a <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> from a string that contains schema JSON.

+            </summary>

+            <param name="json">A <see cref="T:System.String"/> that contains JSON.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> populated from the string that contains JSON.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchema.Parse(System.String,Newtonsoft.Json.Schema.JsonSchemaResolver)">

+            <summary>

+            Parses the specified json.

+            </summary>

+            <param name="json">The json.</param>

+            <param name="resolver">The resolver.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> populated from the string that contains JSON.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchema.WriteTo(Newtonsoft.Json.JsonWriter)">

+            <summary>

+            Writes this schema to a <see cref="T:Newtonsoft.Json.JsonWriter"/>.

+            </summary>

+            <param name="writer">A <see cref="T:Newtonsoft.Json.JsonWriter"/> into which this method will write.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchema.WriteTo(Newtonsoft.Json.JsonWriter,Newtonsoft.Json.Schema.JsonSchemaResolver)">

+            <summary>

+            Writes this schema to a <see cref="T:Newtonsoft.Json.JsonWriter"/> using the specified <see cref="T:Newtonsoft.Json.Schema.JsonSchemaResolver"/>.

+            </summary>

+            <param name="writer">A <see cref="T:Newtonsoft.Json.JsonWriter"/> into which this method will write.</param>

+            <param name="resolver">The resolver used.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchema.ToString">

+            <summary>

+            Returns a <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.

+            </summary>

+            <returns>

+            A <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.

+            </returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Id">

+            <summary>

+            Gets or sets the id.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Title">

+            <summary>

+            Gets or sets the title.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Optional">

+            <summary>

+            Gets or sets whether the object is optional.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.ReadOnly">

+            <summary>

+            Gets or sets whether the object is read only.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Hidden">

+            <summary>

+            Gets or sets whether the object is visible to users.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Transient">

+            <summary>

+            Gets or sets whether the object is transient.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Description">

+            <summary>

+            Gets or sets the description of the object.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Type">

+            <summary>

+            Gets or sets the types of values allowed by the object.

+            </summary>

+            <value>The type.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Pattern">

+            <summary>

+            Gets or sets the pattern.

+            </summary>

+            <value>The pattern.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.MinimumLength">

+            <summary>

+            Gets or sets the minimum length.

+            </summary>

+            <value>The minimum length.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.MaximumLength">

+            <summary>

+            Gets or sets the maximum length.

+            </summary>

+            <value>The maximum length.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.MaximumDecimals">

+            <summary>

+            Gets or sets the maximum decimals.

+            </summary>

+            <value>The maximum decimals.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Minimum">

+            <summary>

+            Gets or sets the minimum.

+            </summary>

+            <value>The minimum.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Maximum">

+            <summary>

+            Gets or sets the maximum.

+            </summary>

+            <value>The maximum.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.MinimumItems">

+            <summary>

+            Gets or sets the minimum number of items.

+            </summary>

+            <value>The minimum number of items.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.MaximumItems">

+            <summary>

+            Gets or sets the maximum number of items.

+            </summary>

+            <value>The maximum number of items.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Items">

+            <summary>

+            Gets or sets the <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> of items.

+            </summary>

+            <value>The <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> of items.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Properties">

+            <summary>

+            Gets or sets the <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> of properties.

+            </summary>

+            <value>The <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> of properties.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.AdditionalProperties">

+            <summary>

+            Gets or sets the <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> of additional properties.

+            </summary>

+            <value>The <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> of additional properties.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.AllowAdditionalProperties">

+            <summary>

+            Gets or sets a value indicating whether additional properties are allowed.

+            </summary>

+            <value>

+                <c>true</c> if additional properties are allowed; otherwise, <c>false</c>.

+            </value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Requires">

+            <summary>

+            Gets or sets the required property if this property is present.

+            </summary>

+            <value>The required property if this property is present.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Identity">

+            <summary>

+            Gets or sets the identity.

+            </summary>

+            <value>The identity.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Enum">

+            <summary>

+            Gets or sets the a collection of valid enum values allowed.

+            </summary>

+            <value>A collection of valid enum values allowed.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Options">

+            <summary>

+            Gets or sets a collection of options.

+            </summary>

+            <value>A collection of options.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Disallow">

+            <summary>

+            Gets or sets disallowed types.

+            </summary>

+            <value>The disallow types.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Default">

+            <summary>

+            Gets or sets the default value.

+            </summary>

+            <value>The default value.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Extends">

+            <summary>

+            Gets or sets the extend <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/>.

+            </summary>

+            <value>The extended <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/>.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchema.Format">

+            <summary>

+            Gets or sets the format.

+            </summary>

+            <value>The format.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Schema.JsonSchemaGenerator">

+            <summary>

+            Generates a <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> from a specified <see cref="T:System.Type"/>.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchemaGenerator.Generate(System.Type)">

+            <summary>

+            Generate a <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> from the specified type.

+            </summary>

+            <param name="type">The type to generate a <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> from.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> generated from the specified type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchemaGenerator.Generate(System.Type,Newtonsoft.Json.Schema.JsonSchemaResolver)">

+            <summary>

+            Generate a <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> from the specified type.

+            </summary>

+            <param name="type">The type to generate a <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> from.</param>

+            <param name="resolver">The <see cref="T:Newtonsoft.Json.Schema.JsonSchemaResolver"/> used to resolve schema references.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> generated from the specified type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchemaGenerator.Generate(System.Type,System.Boolean)">

+            <summary>

+            Generate a <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> from the specified type.

+            </summary>

+            <param name="type">The type to generate a <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> from.</param>

+            <param name="rootSchemaNullable">Specify whether the generated root <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> will be nullable.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> generated from the specified type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Schema.JsonSchemaGenerator.Generate(System.Type,Newtonsoft.Json.Schema.JsonSchemaResolver,System.Boolean)">

+            <summary>

+            Generate a <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> from the specified type.

+            </summary>

+            <param name="type">The type to generate a <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> from.</param>

+            <param name="resolver">The <see cref="T:Newtonsoft.Json.Schema.JsonSchemaResolver"/> used to resolve schema references.</param>

+            <param name="rootSchemaNullable">Specify whether the generated root <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> will be nullable.</param>

+            <returns>A <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/> generated from the specified type.</returns>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchemaGenerator.UndefinedSchemaIdHandling">

+            <summary>

+            Gets or sets how undefined schemas are handled by the serializer.

+            </summary>

+        </member>

+        <member name="P:Newtonsoft.Json.Schema.JsonSchemaGenerator.ContractResolver">

+            <summary>

+            Gets or sets the contract resolver.

+            </summary>

+            <value>The contract resolver.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Schema.JsonSchemaType">

+            <summary>

+            The value types allowed by the <see cref="T:Newtonsoft.Json.Schema.JsonSchema"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Schema.JsonSchemaType.None">

+            <summary>

+            No type specified.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Schema.JsonSchemaType.String">

+            <summary>

+            String type.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Schema.JsonSchemaType.Float">

+            <summary>

+            Float type.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Schema.JsonSchemaType.Integer">

+            <summary>

+            Integer type.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Schema.JsonSchemaType.Boolean">

+            <summary>

+            Boolean type.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Schema.JsonSchemaType.Object">

+            <summary>

+            Object type.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Schema.JsonSchemaType.Array">

+            <summary>

+            Array type.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Schema.JsonSchemaType.Null">

+            <summary>

+            Null type.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Schema.JsonSchemaType.Any">

+            <summary>

+            Any type.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.JsonObjectContract">

+            <summary>

+            Contract details for a <see cref="T:System.Type"/> used by the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.JsonObjectContract.#ctor(System.Type)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Serialization.JsonObjectContract"/> class.

+            </summary>

+            <param name="underlyingType">The underlying type for the contract.</param>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonObjectContract.MemberSerialization">

+            <summary>

+            Gets or sets the object member serialization.

+            </summary>

+            <value>The member object serialization.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonObjectContract.Properties">

+            <summary>

+            Gets the object's properties.

+            </summary>

+            <value>The object's properties.</value>

+        </member>

+        <member name="P:Newtonsoft.Json.Serialization.JsonObjectContract.ParametrizedConstructor">

+            <summary>

+            Gets or sets the parametrized constructor used to create the object.

+            </summary>

+            <value>The parametrized constructor.</value>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.OnErrorAttribute">

+            <summary>

+            When applied to a method, specifies that the method is called when an error occurs serializing an object.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Serialization.ReflectionValueProvider">

+            <summary>

+            Get and set values for a <see cref="T:System.Reflection.MemberInfo"/> using reflection.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.ReflectionValueProvider.#ctor(System.Reflection.MemberInfo)">

+            <summary>

+            Initializes a new instance of the <see cref="T:Newtonsoft.Json.Serialization.ReflectionValueProvider"/> class.

+            </summary>

+            <param name="memberInfo">The member info.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.ReflectionValueProvider.SetValue(System.Object,System.Object)">

+            <summary>

+            Sets the value.

+            </summary>

+            <param name="target">The target to set the value on.</param>

+            <param name="value">The value to set on the target.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Serialization.ReflectionValueProvider.GetValue(System.Object)">

+            <summary>

+            Gets the value.

+            </summary>

+            <param name="target">The target to get the value from.</param>

+            <returns>The value.</returns>

+        </member>

+        <member name="T:Newtonsoft.Json.TypeNameHandling">

+            <summary>

+            Specifies type name handling options for the <see cref="T:Newtonsoft.Json.JsonSerializer"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.TypeNameHandling.None">

+            <summary>

+            Do not include the .NET type name when serializing types.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.TypeNameHandling.Objects">

+            <summary>

+            Include the .NET type name when serializing into a JSON object structure.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.TypeNameHandling.Arrays">

+            <summary>

+            Include the .NET type name when serializing into a JSON array structure.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.TypeNameHandling.All">

+            <summary>

+            Always include the .NET type name when serializing.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ConvertUtils.Convert``1(System.Object)">

+            <summary>

+            Converts the value to the specified type.

+            </summary>

+            <typeparam name="T">The type to convert the value to.</typeparam>

+            <param name="initialValue">The value to convert.</param>

+            <returns>The converted type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ConvertUtils.Convert``1(System.Object,System.Globalization.CultureInfo)">

+            <summary>

+            Converts the value to the specified type.

+            </summary>

+            <typeparam name="T">The type to convert the value to.</typeparam>

+            <param name="initialValue">The value to convert.</param>

+            <param name="culture">The culture to use when converting.</param>

+            <returns>The converted type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ConvertUtils.Convert(System.Object,System.Globalization.CultureInfo,System.Type)">

+            <summary>

+            Converts the value to the specified type.

+            </summary>

+            <param name="initialValue">The value to convert.</param>

+            <param name="culture">The culture to use when converting.</param>

+            <param name="targetType">The type to convert the value to.</param>

+            <returns>The converted type.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ConvertUtils.TryConvert``1(System.Object,``0@)">

+            <summary>

+            Converts the value to the specified type.

+            </summary>

+            <typeparam name="T">The type to convert the value to.</typeparam>

+            <param name="initialValue">The value to convert.</param>

+            <param name="convertedValue">The converted value if the conversion was successful or the default value of <c>T</c> if it failed.</param>

+            <returns>

+                <c>true</c> if <c>initialValue</c> was converted successfully; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ConvertUtils.TryConvert``1(System.Object,System.Globalization.CultureInfo,``0@)">

+            <summary>

+            Converts the value to the specified type.

+            </summary>

+            <typeparam name="T">The type to convert the value to.</typeparam>

+            <param name="initialValue">The value to convert.</param>

+            <param name="culture">The culture to use when converting.</param>

+            <param name="convertedValue">The converted value if the conversion was successful or the default value of <c>T</c> if it failed.</param>

+            <returns>

+                <c>true</c> if <c>initialValue</c> was converted successfully; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ConvertUtils.TryConvert(System.Object,System.Globalization.CultureInfo,System.Type,System.Object@)">

+            <summary>

+            Converts the value to the specified type.

+            </summary>

+            <param name="initialValue">The value to convert.</param>

+            <param name="culture">The culture to use when converting.</param>

+            <param name="targetType">The type to convert the value to.</param>

+            <param name="convertedValue">The converted value if the conversion was successful or the default value of <c>T</c> if it failed.</param>

+            <returns>

+                <c>true</c> if <c>initialValue</c> was converted successfully; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ConvertUtils.ConvertOrCast``1(System.Object)">

+            <summary>

+            Converts the value to the specified type. If the value is unable to be converted, the

+            value is checked whether it assignable to the specified type.

+            </summary>

+            <typeparam name="T">The type to convert or cast the value to.</typeparam>

+            <param name="initialValue">The value to convert.</param>

+            <returns>The converted type. If conversion was unsuccessful, the initial value is returned if assignable to the target type</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ConvertUtils.ConvertOrCast``1(System.Object,System.Globalization.CultureInfo)">

+            <summary>

+            Converts the value to the specified type. If the value is unable to be converted, the

+            value is checked whether it assignable to the specified type.

+            </summary>

+            <typeparam name="T">The type to convert or cast the value to.</typeparam>

+            <param name="initialValue">The value to convert.</param>

+            <param name="culture">The culture to use when converting.</param>

+            <returns>The converted type. If conversion was unsuccessful, the initial value is returned if assignable to the target type</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ConvertUtils.ConvertOrCast(System.Object,System.Globalization.CultureInfo,System.Type)">

+            <summary>

+            Converts the value to the specified type. If the value is unable to be converted, the

+            value is checked whether it assignable to the specified type.

+            </summary>

+            <param name="initialValue">The value to convert.</param>

+            <param name="culture">The culture to use when converting.</param>

+            <param name="targetType">The type to convert or cast the value to.</param>

+            <returns>

+            The converted type. If conversion was unsuccessful, the initial value

+            is returned if assignable to the target type.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ConvertUtils.TryConvertOrCast``1(System.Object,``0@)">

+            <summary>

+            Converts the value to the specified type. If the value is unable to be converted, the

+            value is checked whether it assignable to the specified type.

+            </summary>

+            <typeparam name="T">The type to convert the value to.</typeparam>

+            <param name="initialValue">The value to convert.</param>

+            <param name="convertedValue">The converted value if the conversion was successful or the default value of <c>T</c> if it failed.</param>

+            <returns>

+                <c>true</c> if <c>initialValue</c> was converted successfully or is assignable; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ConvertUtils.TryConvertOrCast``1(System.Object,System.Globalization.CultureInfo,``0@)">

+            <summary>

+            Converts the value to the specified type. If the value is unable to be converted, the

+            value is checked whether it assignable to the specified type.

+            </summary>

+            <typeparam name="T">The type to convert the value to.</typeparam>

+            <param name="initialValue">The value to convert.</param>

+            <param name="culture">The culture to use when converting.</param>

+            <param name="convertedValue">The converted value if the conversion was successful or the default value of <c>T</c> if it failed.</param>

+            <returns>

+                <c>true</c> if <c>initialValue</c> was converted successfully or is assignable; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ConvertUtils.TryConvertOrCast(System.Object,System.Globalization.CultureInfo,System.Type,System.Object@)">

+            <summary>

+            Converts the value to the specified type. If the value is unable to be converted, the

+            value is checked whether it assignable to the specified type.

+            </summary>

+            <param name="initialValue">The value to convert.</param>

+            <param name="culture">The culture to use when converting.</param>

+            <param name="targetType">The type to convert the value to.</param>

+            <param name="convertedValue">The converted value if the conversion was successful or the default value of <c>T</c> if it failed.</param>

+            <returns>

+                <c>true</c> if <c>initialValue</c> was converted successfully or is assignable; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.EnumUtils.Parse``1(System.String)">

+            <summary>

+            Parses the specified enum member name, returning it's value.

+            </summary>

+            <param name="enumMemberName">Name of the enum member.</param>

+            <returns></returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.EnumUtils.Parse``1(System.String,System.Boolean)">

+            <summary>

+            Parses the specified enum member name, returning it's value.

+            </summary>

+            <param name="enumMemberName">Name of the enum member.</param>

+            <param name="ignoreCase">If set to <c>true</c> ignore case.</param>

+            <returns></returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.EnumUtils.GetNamesAndValues``1">

+            <summary>

+            Gets a dictionary of the names and values of an Enum type.

+            </summary>

+            <returns></returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.EnumUtils.GetNamesAndValues``2">

+            <summary>

+            Gets a dictionary of the names and values of an Enum type.

+            </summary>

+            <returns></returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.EnumUtils.GetNamesAndValues``1(System.Type)">

+            <summary>

+            Gets a dictionary of the names and values of an Enum type.

+            </summary>

+            <param name="enumType">The enum type to get names and values for.</param>

+            <returns></returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.EnumUtils.GetMaximumValue``1(System.Type)">

+            <summary>

+            Gets the maximum valid value of an Enum type. Flags enums are ORed.

+            </summary>

+            <typeparam name="TEnumType">The type of the returned value. Must be assignable from the enum's underlying value type.</typeparam>

+            <param name="enumType">The enum type to get the maximum value for.</param>

+            <returns></returns>

+        </member>

+        <member name="T:Newtonsoft.Json.JsonToken">

+            <summary>

+            Specifies the type of Json token.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.None">

+            <summary>

+            This is returned by the <see cref="T:Newtonsoft.Json.JsonReader"/> if a <see cref="M:Newtonsoft.Json.JsonReader.Read"/> method has not been called. 

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.StartObject">

+            <summary>

+            An object start token.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.StartArray">

+            <summary>

+            An array start token.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.StartConstructor">

+            <summary>

+            A constructor start token.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.PropertyName">

+            <summary>

+            An object property name.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.Comment">

+            <summary>

+            A comment.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.Raw">

+            <summary>

+            Raw JSON.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.Integer">

+            <summary>

+            An interger.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.Float">

+            <summary>

+            A float.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.String">

+            <summary>

+            A string.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.Boolean">

+            <summary>

+            A boolean.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.Null">

+            <summary>

+            A null token.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.Undefined">

+            <summary>

+            An undefined token.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.EndObject">

+            <summary>

+            An object end token.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.EndArray">

+            <summary>

+            An array end token.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.EndConstructor">

+            <summary>

+            A constructor end token.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.Date">

+            <summary>

+            A Date.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.JsonToken.Bytes">

+            <summary>

+            Byte data.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.WriteState">

+            <summary>

+            Specifies the state of the <see cref="T:Newtonsoft.Json.JsonWriter"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.WriteState.Error">

+            <summary>

+            An exception has been thrown, which has left the <see cref="T:Newtonsoft.Json.JsonWriter"/> in an invalid state.

+            You may call the <see cref="M:Newtonsoft.Json.JsonWriter.Close"/> method to put the <see cref="T:Newtonsoft.Json.JsonWriter"/> in the <c>Closed</c> state.

+            Any other <see cref="T:Newtonsoft.Json.JsonWriter"/> method calls results in an <see cref="T:System.InvalidOperationException"/> being thrown. 

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.WriteState.Closed">

+            <summary>

+            The <see cref="M:Newtonsoft.Json.JsonWriter.Close"/> method has been called. 

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.WriteState.Object">

+            <summary>

+            An object is being written. 

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.WriteState.Array">

+            <summary>

+            A array is being written.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.WriteState.Constructor">

+            <summary>

+            A constructor is being written.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.WriteState.Property">

+            <summary>

+            A property is being written.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.WriteState.Start">

+            <summary>

+            A write method has not been called.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Formatting">

+            <summary>

+            Specifies formatting options for the <see cref="T:Newtonsoft.Json.JsonTextWriter"/>.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Formatting.None">

+            <summary>

+            No special formatting is applied. This is the default.

+            </summary>

+        </member>

+        <member name="F:Newtonsoft.Json.Formatting.Indented">

+            <summary>

+            Causes child objects to be indented according to the <see cref="P:Newtonsoft.Json.JsonTextWriter.Indentation"/> and <see cref="P:Newtonsoft.Json.JsonTextWriter.IndentChar"/> settings.

+            </summary>

+        </member>

+        <member name="T:Newtonsoft.Json.Utilities.StringBuffer">

+            <summary>

+            Builds a string. Unlike StringBuilder this class lets you reuse it's internal buffer.

+            </summary>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.IsNullOrEmpty(System.Collections.ICollection)">

+            <summary>

+            Determines whether the collection is null or empty.

+            </summary>

+            <param name="collection">The collection.</param>

+            <returns>

+                <c>true</c> if the collection is null or empty; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.IsNullOrEmpty``1(System.Collections.Generic.ICollection{``0})">

+            <summary>

+            Determines whether the collection is null or empty.

+            </summary>

+            <param name="collection">The collection.</param>

+            <returns>

+                <c>true</c> if the collection is null or empty; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.IsNullOrEmptyOrDefault``1(System.Collections.Generic.IList{``0})">

+            <summary>

+            Determines whether the collection is null, empty or its contents are uninitialized values.

+            </summary>

+            <param name="list">The list.</param>

+            <returns>

+                <c>true</c> if the collection is null or empty or its contents are uninitialized values; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.Slice``1(System.Collections.Generic.IList{``0},System.Nullable{System.Int32},System.Nullable{System.Int32})">

+            <summary>

+            Makes a slice of the specified list in between the start and end indexes.

+            </summary>

+            <param name="list">The list.</param>

+            <param name="start">The start index.</param>

+            <param name="end">The end index.</param>

+            <returns>A slice of the list.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.Slice``1(System.Collections.Generic.IList{``0},System.Nullable{System.Int32},System.Nullable{System.Int32},System.Nullable{System.Int32})">

+            <summary>

+            Makes a slice of the specified list in between the start and end indexes,

+            getting every so many items based upon the step.

+            </summary>

+            <param name="list">The list.</param>

+            <param name="start">The start index.</param>

+            <param name="end">The end index.</param>

+            <param name="step">The step.</param>

+            <returns>A slice of the list.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.GroupBy``2(System.Collections.Generic.ICollection{``1},System.Func{``1,``0})">

+            <summary>

+            Group the collection using a function which returns the key.

+            </summary>

+            <param name="source">The source collection to group.</param>

+            <param name="keySelector">The key selector.</param>

+            <returns>A Dictionary with each key relating to a list of objects in a list grouped under it.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.CollectionUtils.AddRange``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0})">

+            <summary>

+            Adds the elements of the specified collection to the specified generic IList.

+            </summary>

+            <param name="initial">The list to add to.</param>

+            <param name="collection">The collection of elements to add.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.GetCollectionItemType(System.Type)">

+            <summary>

+            Gets the type of the typed collection's items.

+            </summary>

+            <param name="type">The type.</param>

+            <returns>The type of the typed collection's items.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.ItemsUnitializedValue``1(System.Collections.Generic.IList{``0})">

+            <summary>

+            Tests whether the list's items are their unitialized value.

+            </summary>

+            <param name="list">The list.</param>

+            <returns>Whether the list's items are their unitialized value</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.GetMemberUnderlyingType(System.Reflection.MemberInfo)">

+            <summary>

+            Gets the member's underlying type.

+            </summary>

+            <param name="member">The member.</param>

+            <returns>The underlying type of the member.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.IsIndexedProperty(System.Reflection.MemberInfo)">

+            <summary>

+            Determines whether the member is an indexed property.

+            </summary>

+            <param name="member">The member.</param>

+            <returns>

+                <c>true</c> if the member is an indexed property; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.IsIndexedProperty(System.Reflection.PropertyInfo)">

+            <summary>

+            Determines whether the property is an indexed property.

+            </summary>

+            <param name="property">The property.</param>

+            <returns>

+                <c>true</c> if the property is an indexed property; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.GetMemberValue(System.Reflection.MemberInfo,System.Object)">

+            <summary>

+            Gets the member's value on the object.

+            </summary>

+            <param name="member">The member.</param>

+            <param name="target">The target object.</param>

+            <returns>The member's value on the object.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.SetMemberValue(System.Reflection.MemberInfo,System.Object,System.Object)">

+            <summary>

+            Sets the member's value on the target object.

+            </summary>

+            <param name="member">The member.</param>

+            <param name="target">The target.</param>

+            <param name="value">The value.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.CanReadMemberValue(System.Reflection.MemberInfo)">

+            <summary>

+            Determines whether the specified MemberInfo can be read.

+            </summary>

+            <param name="member">The MemberInfo to determine whether can be read.</param>

+            <returns>

+                <c>true</c> if the specified MemberInfo can be read; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.ReflectionUtils.CanSetMemberValue(System.Reflection.MemberInfo)">

+            <summary>

+            Determines whether the specified MemberInfo can be set.

+            </summary>

+            <param name="member">The MemberInfo to determine whether can be set.</param>

+            <returns>

+                <c>true</c> if the specified MemberInfo can be set; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.StringUtils.ContainsWhiteSpace(System.String)">

+            <summary>

+            Determines whether the string contains white space.

+            </summary>

+            <param name="s">The string to test for white space.</param>

+            <returns>

+                <c>true</c> if the string contains white space; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.StringUtils.IsWhiteSpace(System.String)">

+            <summary>

+            Determines whether the string is all white space. Empty string will return false.

+            </summary>

+            <param name="s">The string to test whether it is all white space.</param>

+            <returns>

+                <c>true</c> if the string is all white space; otherwise, <c>false</c>.

+            </returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.StringUtils.EnsureEndsWith(System.String,System.String)">

+            <summary>

+            Ensures the target string ends with the specified string.

+            </summary>

+            <param name="target">The target.</param>

+            <param name="value">The value.</param>

+            <returns>The target string with the value string at the end.</returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.StringUtils.IfNotNullOrEmpty(System.String,System.Action{System.String})">

+            <summary>

+            Perform an action if the string is not null or empty.

+            </summary>

+            <param name="value">The value.</param>

+            <param name="action">The action to perform.</param>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.StringUtils.Indent(System.String,System.Int32)">

+            <summary>

+            Indents the specified string.

+            </summary>

+            <param name="s">The string to indent.</param>

+            <param name="indentation">The number of characters to indent by.</param>

+            <returns></returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.StringUtils.Indent(System.String,System.Int32,System.Char)">

+            <summary>

+            Indents the specified string.

+            </summary>

+            <param name="s">The string to indent.</param>

+            <param name="indentation">The number of characters to indent by.</param>

+            <param name="indentChar">The indent character.</param>

+            <returns></returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.StringUtils.NumberLines(System.String)">

+            <summary>

+            Numbers the lines.

+            </summary>

+            <param name="s">The string to number.</param>

+            <returns></returns>

+        </member>

+        <member name="M:Newtonsoft.Json.Utilities.StringUtils.NullEmptyString(System.String)">

+            <summary>

+            Nulls an empty string.

+            </summary>

+            <param name="s">The string.</param>

+            <returns>Null if the string was null, otherwise the string unchanged.</returns>

+        </member>

+    </members>

+</doc>

diff --git a/bin/Newtonsoft.Json.dll b/bin/Newtonsoft.Json.dll
index 3b14448..177d9b5 100644
--- a/bin/Newtonsoft.Json.dll
+++ b/bin/Newtonsoft.Json.dll
diff --git a/bin/Newtonsoft.Json.pdb b/bin/Newtonsoft.Json.pdb
index a8b8b8f..892546a 100644
--- a/bin/Newtonsoft.Json.pdb
+++ b/bin/Newtonsoft.Json.pdb
diff --git a/bin/OpenSim.exe.config b/bin/OpenSim.exe.config
index 3c7adf5..4e7ef51 100755
--- a/bin/OpenSim.exe.config
+++ b/bin/OpenSim.exe.config
@@ -12,7 +12,7 @@
   <log4net>
     <appender name="Console" type="OpenSim.Framework.Console.OpenSimAppender, OpenSim.Framework.Console">
       <layout type="log4net.Layout.PatternLayout">
-        <conversionPattern value="%date{HH:mm:ss} - %message" />
+        <conversionPattern value="%date{HH:mm:ss,fff} - %message" />
       </layout>
     </appender>
 
diff --git a/bin/OpenSim.ini.example b/bin/OpenSim.ini.example
index 3e9d376..37c0192 100644
--- a/bin/OpenSim.ini.example
+++ b/bin/OpenSim.ini.example
@@ -1308,10 +1308,13 @@
     ;MessagingModule = GroupsMessagingModule
     ;MessagingEnabled = true
 
-    ; Service connector to Groups Service [Select One]
-    ; XmlRpc Service Connector to the Flotsam XmlRpc Groups Service Implementation
+    ; Service connector to Groups Service [Select One] ServicesConnectorModule
+
+    ; XmlRpc Service Connector to the Flotsam XmlRpc Groups Service settings
     ;ServicesConnectorModule = XmlRpcGroupsServicesConnector
-    ;XmlRpcServiceURL        = http://yourxmlrpcserver.com/xmlrpc.php
+    ;GroupsServerURI        = http://yourxmlrpcserver.com/xmlrpc.php
+
+    ; XmlRpc Service Settings
     ;XmlRpcServiceReadKey    = 1234
     ;XmlRpcServiceWriteKey   = 1234
 
diff --git a/bin/config-include/GridCommon.ini.example b/bin/config-include/GridCommon.ini.example
index 6da0f1e..cc86501 100644
--- a/bin/config-include/GridCommon.ini.example
+++ b/bin/config-include/GridCommon.ini.example
@@ -15,12 +15,14 @@
     ;
     InventoryServerURI = "http://myinventoryserver.com:8003"
 
+
 [GridService]
     ;
     ; change this to your grid-wide grid server
     ;
     GridServerURI = "http://mygridserver.com:8003"
 
+
 [Modules]
     ;; Choose 0 or 1 cache modules, and the corresponding config file, if it exists.
     ;; Copy the config .example file into your own .ini file and change configs there
diff --git a/prebuild.xml b/prebuild.xml
index 908855f..d2456b2 100644
--- a/prebuild.xml
+++ b/prebuild.xml
@@ -765,7 +765,6 @@
       <Reference name="OpenSim.Region.Physics.Manager"/>
 
       <!-- For scripting in funny languages by default -->
-      <Reference name="Microsoft.JScript"/>
       <Reference name="XMLRPC.dll"/>
       <Reference name="OpenSim.Framework.Communications"/>
       <Reference name="Nini.dll" />
@@ -1619,7 +1618,6 @@
       <Reference name="GlynnTucker.Cache.dll"/>
 
       <!-- For scripting in funny languages by default -->
-      <Reference name="Microsoft.JScript"/>
       <Reference name="XMLRPC.dll"/>
       <Reference name="OpenSim.Framework.Communications"/>
       <Reference name="Nini.dll" />
@@ -1702,7 +1700,6 @@
       <Reference name="Mono.Addins.dll" />
 
       <!-- For scripting in funny languages by default -->
-      <Reference name="Microsoft.JScript"/>
       <Reference name="XMLRPC.dll"/>
       <Reference name="OpenSim.Framework.Communications"/>
       <Reference name="Nini.dll" />
@@ -2707,7 +2704,6 @@
 
       <ReferencePath>../../../../../bin/</ReferencePath>
       <Reference name="System"/>
-      <Reference name="Microsoft.JScript"/>
       <Reference name="OpenSim.Framework" />
       <Reference name="OpenSim.Region.Framework" />
       <Reference name="OpenSim.Region.ScriptEngine.Shared"/>
@@ -2844,7 +2840,6 @@
       <Reference name="Mono.Addins"/>
 
       <!-- For scripting in funny languages by default -->
-      <Reference name="Microsoft.JScript"/>
       <Reference name="XMLRPC.dll"/>
       <Reference name="OpenSim.Framework.Communications"/>
       <Reference name="Nini.dll" />
@@ -3306,7 +3301,6 @@
       <Reference name="nunit.framework.dll"/>
 
       <!-- For scripting in funny languages by default -->
-      <Reference name="Microsoft.JScript"/>
       <Reference name="XMLRPC.dll"/>
       <Reference name="OpenSim.Framework.Communications"/>
       <Reference name="Nini.dll" />
@@ -3370,7 +3364,6 @@
       <Reference name="nunit.framework.dll"/>
 
       <!-- For scripting in funny languages by default -->
-      <Reference name="Microsoft.JScript"/>
       <Reference name="XMLRPC.dll"/>
       <Reference name="OpenSim.Framework.Communications"/>
       <Reference name="Nini.dll" />