cordova-plugin-pushnotification-parsepushnotification/src/wp8/Parse.xml

Cordova Parse Push Notification plugin

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Parse</name>
    </assembly>
    <members>
        <member name="M:Parse.Internal.IParseAuthenticationProvider.AuthenticateAsync(System.Threading.CancellationToken)">
            <summary>
            Authenticates with the service.
            </summary>
            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.Internal.IParseAuthenticationProvider.Deauthenticate">
            <summary>
            Deauthenticates (logs out) the user associated with this provider. This
            call may block.
            </summary>
        </member>
        <member name="M:Parse.Internal.IParseAuthenticationProvider.RestoreAuthentication(System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Restores authentication that has been serialized, such as session keys,
            etc.
            </summary>
            <param name="authData">The auth data for the provider. This value may be null
            when unlinking an account.</param>
            <returns><c>true</c> iff the authData was successfully synchronized. A <c>false</c> return
            value indicates that the user should no longer be associated because of bad auth
            data.</returns>
        </member>
        <member name="P:Parse.Internal.IParseAuthenticationProvider.AuthType">
            <summary>
            Provides a unique name for the type of authentication the provider does.
            For example, the FacebookAuthenticationProvider would return "facebook".
            </summary>
        </member>
        <member name="M:Parse.Internal.FacebookAuthenticationProvider.TryParseOAuthCallbackUrl(System.Uri,System.Collections.Generic.IDictionary{System.String,System.String}@)">
            <summary>
            Parses a uri, looking for a base uri that represents facebook login completion, and then
            converting the query string into a dictionary of key-value pairs. (e.g. access_token)
            </summary>
        </member>
        <member name="T:Parse.Internal.FlexibleDictionaryWrapper`2">
            <summary>
            Provides a Dictionary implementation that can delegate to any other
            dictionary, regardless of its value type.  Used for coercion of
            dictionaries when returning them to users.
            </summary>
            <typeparam name="TOut">The resulting type of value in the dictionary.</typeparam>
            <typeparam name="TIn">The original type of value in the dictionary.</typeparam>
        </member>
        <member name="T:Parse.Internal.FlexibleListWrapper`2">
            <summary>
            Provides a List implementation that can delegate to any other
            list, regardless of its value type.  Used for coercion of
            lists when returning them to users.
            </summary>
            <typeparam name="TOut">The resulting type of value in the list.</typeparam>
            <typeparam name="TIn">The original type of value in the list.</typeparam>
        </member>
        <member name="T:Parse.Internal.IdentityEqualityComparer`1">
            <summary>
            An equality comparer that uses the object identity (i.e. ReferenceEquals)
            rather than .Equals, allowing identity to be used for checking equality in
            ISets and IDictionaries.
            </summary>
        </member>
        <member name="T:Parse.Internal.InternalExtensions">
            <summary>
            Provides helper methods that allow us to use terser code elsewhere.
            </summary>
        </member>
        <member name="M:Parse.Internal.InternalExtensions.Safe``1(System.Threading.Tasks.Task{``0})">
            <summary>
            Ensures a task (even null) is awaitable.
            </summary>
            <typeparam name="T"></typeparam>
            <param name="task"></param>
            <returns></returns>
        </member>
        <member name="M:Parse.Internal.InternalExtensions.Safe(System.Threading.Tasks.Task)">
            <summary>
            Ensures a task (even null) is awaitable.
            </summary>
            <param name="task"></param>
            <returns></returns>
        </member>
        <member name="M:Parse.Internal.InternalExtensions.GetPartial``1(Parse.ParseObject,Parse.Internal.InternalExtensions.PartialAccessor{``0})">
            <summary>
            Partial methods cannot return a value, so we instead make partial accessors
            use ref params. This helper can be used to write code more normally so we get
            the out-param or default when calling a partial method. Given a partial method:
            partial void GetFoo(ref string foo)
            we can say string foo = this.GetPartial&lt;string&gt;(GetFoo);
            </summary>
            <typeparam name="T"></typeparam>
            <param name="self"></param>
            <param name="action"></param>
        </member>
        <member name="M:Parse.Internal.InternalExtensions.PartialAsync``1(System.Object,Parse.Internal.InternalExtensions.PartialAccessor{System.Threading.Tasks.Task{``0}})">
            <summary>
            Partial methods cannot return a value, so we instead make partial accessors
            use ref params. This means you cannot effectively make a partial which is
            async. This code helps create a design pattern where a partial takes a ref Task
            param and we can await the PartialAsync of it. Given a partial method:
            partial void FooAsync(ref Task&lt;string&gt; task)
            we can say string foo = await PartialAsync&lt;string&gt;(FooAsync);
            </summary>
            <typeparam name="T"></typeparam>
            <param name="self"></param>
            <param name="partial"></param>
            <returns></returns>
        </member>
        <member name="T:Parse.Internal.IParseFieldOperation">
            <summary>
            A ParseFieldOperation represents a modification to a value in a ParseObject.
            For example, setting, deleting, or incrementing a value are all different kinds of
            ParseFieldOperations.  ParseFieldOperations themselves can be considered to be
            immutable.
            </summary>
        </member>
        <member name="M:Parse.Internal.IParseFieldOperation.Encode">
            <summary>
            Converts the ParseFieldOperation to a data structure that can be converted to JSON and sent to
            Parse as part of a save operation.
            </summary>
            <returns>An object to be JSONified.</returns>
        </member>
        <member name="M:Parse.Internal.IParseFieldOperation.MergeWithPrevious(Parse.Internal.IParseFieldOperation)">
            <summary>
            Returns a field operation that is composed of a previous operation followed by
            this operation. This will not mutate either operation. However, it may return
            <code>this</code> if the current operation is not affected by previous changes.
            For example:
              {increment by 2}.MergeWithPrevious({set to 5})       -> {set to 7}
                    {set to 5}.MergeWithPrevious({increment by 2}) -> {set to 5}
                   {add "foo"}.MergeWithPrevious({delete})         -> {set to ["foo"]}
                      {delete}.MergeWithPrevious({add "foo"})      -> {delete}        /// </summary>
            <param name="previous">The most recent operation on the field, or null if none.</param>
            <returns>A new ParseFieldOperation or this.</returns>
        </member>
        <member name="M:Parse.Internal.IParseFieldOperation.Apply(System.Object,Parse.ParseObject,System.String)">
            <summary>
            Returns a new estimated value based on a previous value and this operation.  This
            value is not intended to be sent to Parse, but it is used locally on the client to
            inspect the most likely current value for a field.
            
            The key and object are used solely for ParseRelation to be able to construct objects
            that refer back to their parents.
            </summary>
            <param name="oldValue">The previous value for the field.</param>
            <param name="obj">The object that contains this value.</param>
            <param name="key">The key that this value is for.</param>
            <returns>The new value for the field.</returns>
        </member>
        <member name="T:Parse.Internal.Json">
            <summary>
            A simple recursive-descent JSON Parser based on the grammar defined at http://www.json.org
            and http://tools.ietf.org/html/rfc4627
            </summary>
        </member>
        <member name="F:Parse.Internal.Json.startOfString">
            <summary>
            Place at the start of a regex to force the match to begin wherever the search starts (i.e.
            anchored at the index of the first character of the search, even when that search starts
            in the middle of the string).
            </summary>
        </member>
        <member name="M:Parse.Internal.Json.Parse(System.String)">
            <summary>
            Parses a JSON-text as defined in http://tools.ietf.org/html/rfc4627, returning an
            IDictionary&lt;string, object&gt; or an IList&lt;object&gt; depending on whether
            the value was an array or dictionary. Nested objects also match these types.
            </summary>
        </member>
        <member name="M:Parse.Internal.Json.Encode(System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Encodes a dictionary into a JSON string. Suppots values that are
            IDictionary&lt;string, object&gt;, IList&lt;object&gt;, strings,
            nulls, and any of the primitive types.
            </summary>
        </member>
        <member name="M:Parse.Internal.Json.Encode(System.Collections.Generic.IList{System.Object})">
            <summary>
            Encodes a list into a JSON string. Suppots values that are
            IDictionary&lt;string, object&gt;, IList&lt;object&gt;, strings,
            nulls, and any of the primitive types.
            </summary>
        </member>
        <member name="M:Parse.Internal.Json.Encode(System.Object)">
            <summary>
            Encodes an object into a JSON string.
            </summary>
        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.ParseObject(System.Object@)">
            <summary>
            Parses JSON object syntax (e.g. '{}')
            </summary>
        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.ParseMember(System.Object@)">
            <summary>
            Parses JSON member syntax (e.g. '"keyname" : null')
            </summary>
        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.ParseArray(System.Object@)">
            <summary>
            Parses JSON array syntax (e.g. '[]')
            </summary>
        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.ParseValue(System.Object@)">
            <summary>
            Parses a value (i.e. the right-hand side of an object member assignment or
            an element in an array)
            </summary>
        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.ParseString(System.Object@)">
            <summary>
            Parses a JSON string (e.g. '"foo\u1234bar\n"')
            </summary>
        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.ParseNumber(System.Object@)">
            <summary>
            Parses a number. Returns a long if the number is an integer or has an exponent,
            otherwise returns a double.
            </summary>
        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.Accept(System.Text.RegularExpressions.Regex,System.Text.RegularExpressions.Match@)">
            <summary>
            Matches the string to a regex, consuming part of the string and returning the match.
            </summary>
        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.Accept(System.Char)">
            <summary>
            Find the first occurences of a character, consuming part of the string.
            </summary>
        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.Accept(System.Char[])">
            <summary>
            Find the first occurences of a string, consuming part of the string.
            </summary>
        </member>
        <member name="T:Parse.Internal.ParseDeleteOperation">
            <summary>
            An operation where a field is deleted from the object.
            </summary>
        </member>
        <member name="T:Parse.ParseConfig">
            <summary>
            The ParseConfig is a representation of the remote configuration object,
            that enables you to add things like feature gating, a/b testing or simple "Message of the day".
            </summary>
        </member>
        <member name="M:Parse.ParseConfig.GetAsync">
            <summary>
            Retrieves the ParseConfig asynchronously from the server.
            </summary>
            <returns>ParseConfig object that was fetched</returns>
        </member>
        <member name="M:Parse.ParseConfig.GetAsync(System.Threading.CancellationToken)">
            <summary>
            Retrieves the ParseConfig asynchronously from the server.
            </summary>
            <param name="cancellationToken">The cancellation token.</param>
            <returns>ParseConfig object that was fetched</returns>
        </member>
        <member name="M:Parse.ParseConfig.Get``1(System.String)">
            <summary>
            Gets a value for the key of a particular type.
            </summary>
            <typeparam name="T">The type to convert the value to. Supported types are
            ParseObject and its descendents, Parse types such as ParseRelation and ParseGeopoint,
            primitive types,IList&lt;T&gt;, IDictionary&lt;string, T&gt; and strings.</typeparam>
            <param name="key">The key of the element to get.</param>
            <exception cref="T:System.Collections.Generic.KeyNotFoundException">The property is retrieved
            and <paramref name="key"/> is not found.</exception>
            <exception cref="T:System.FormatException">The property under this <paramref name="key"/>
            key was found, but of a different type.</exception>
        </member>
        <member name="M:Parse.ParseConfig.TryGetValue``1(System.String,``0@)">
            <summary>
            Populates result with the value for the key, if possible.
            </summary>
            <typeparam name="T">The desired type for the value.</typeparam>
            <param name="key">The key to retrieve a value for.</param>
            <param name="result">The value for the given key, converted to the
            requested type, or null if unsuccessful.</param>
            <returns>true if the lookup and conversion succeeded, otherwise false.</returns>
        </member>
        <member name="P:Parse.ParseConfig.CurrentConfig">
            <summary>
            Gets the latest fetched ParseConfig.
            </summary>
            <returns>ParseConfig object</returns>
        </member>
        <member name="P:Parse.ParseConfig.Item(System.String)">
            <summary>
            Gets a value on the config.
            </summary>
            <param name="key">The key for the parameter.</param>
            <exception cref="T:System.Collections.Generic.KeyNotFoundException">The property is
            retrieved and <paramref name="key"/> is not found.</exception>
            <returns>The value for the key.</returns>
        </member>
        <member name="T:Parse.ParseFieldNameAttribute">
            <summary>
            Specifies a field name for a property on a ParseObject subclass.
            </summary>
        </member>
        <member name="M:Parse.ParseFieldNameAttribute.#ctor(System.String)">
            <summary>
            Constructs a new ParseFieldName attribute.
            </summary>
            <param name="fieldName">The name of the field on the ParseObject that the
            property represents.</param>
        </member>
        <member name="P:Parse.ParseFieldNameAttribute.FieldName">
            <summary>
            Gets the name of the field represented by this property.
            </summary>
        </member>
        <member name="M:Parse.Internal.ReflectionHelpers.FindConstructor(System.Type,System.Type[])">
            <summary>
            This method helps simplify the process of getting a constructor for a type.
            A method like this exists in .NET but is not allowed in a Portable Class Library,
            so we've built our own.
            </summary>
            <param name="self"></param>
            <param name="parameterTypes"></param>
            <returns></returns>
        </member>
        <member name="T:Parse.Internal.SynchronizedEventHandler`1">
            <summary>
            Represents an event handler that calls back from the synchronization context
            that subscribed.
            <typeparam name="T">Should look like an EventArgs, but may not inherit EventArgs if T is implemented by the Windows team.</typeparam>
            </summary>
        </member>
        <member name="T:Parse.Internal.TaskQueue">
            <summary>
            A helper class for enqueuing tasks
            </summary>
        </member>
        <member name="F:Parse.Internal.TaskQueue.tail">
            <summary>
            We only need to keep the tail of the queue.  Cancelled tasks will
            just complete normally/immediately when their turn arrives.
            </summary>
        </member>
        <member name="M:Parse.Internal.TaskQueue.GetTaskToAwait(System.Threading.CancellationToken)">
            <summary>
            Gets a cancellable task that can be safely awaited and is dependent
            on the current tail of the queue. This essentially gives us a proxy
            for the tail end of the queue whose awaiting can be cancelled.
            </summary>
            <param name="cancellationToken">A cancellation token that cancels
            the task even if the task is still in the queue. This allows the
            running task to return immediately without breaking the dependency
            chain. It also ensures that errors do not propagate.</param>
            <returns>A new task that should be awaited by enqueued tasks.</returns>
        </member>
        <member name="M:Parse.Internal.TaskQueue.Enqueue``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)">
            <summary>
            Enqueues a task created by <paramref name="taskStart"/>.  If the task is
            cancellable (or should be able to be cancelled while it is waiting in the
            queue), pass a cancellationToken.
            </summary>
            <typeparam name="T">The type of task.</typeparam>
            <param name="taskStart">A function given a task to await once state is
            snapshotted (e.g. after capturing session tokens at the time of the save call).
            Awaiting this task will wait for the created task's turn in the queue.</param>
            <param name="cancellationToken">A cancellation token that can be used to
            cancel waiting in the queue.</param>
            <returns>The task created by the taskStart function.</returns>
        </member>
        <member name="T:Parse.ParseClassNameAttribute">
            <summary>
            Defines the class name for a subclass of ParseObject.
            </summary>
        </member>
        <member name="M:Parse.ParseClassNameAttribute.#ctor(System.String)">
            <summary>
            Constructs a new ParseClassName attribute.
            </summary>
            <param name="className">The class name to associate with the ParseObject subclass.</param>
        </member>
        <member name="P:Parse.ParseClassNameAttribute.ClassName">
            <summary>
            Gets the class name to associate with the ParseObject subclass.
            </summary>
        </member>
        <member name="T:Parse.ParseFile">
            <summary>
            ParseFile is a local representation of a file that is saved to the Parse cloud.
            </summary>
            <example>
            The workflow is to construct a <see cref="T:Parse.ParseFile"/> with data and a filename,
            then save it and set it as a field on a ParseObject:
            
            <code>
            var file = new ParseFile("hello.txt",
                new MemoryStream(Encoding.UTF8.GetBytes("hello")));
            await file.SaveAsync();
            var obj = new ParseObject("TestObject");
            obj["file"] = file;
            await obj.SaveAsync();
            </code>
            </example>
        </member>
        <member name="M:Parse.ParseFile.#ctor(System.String,System.Byte[],System.String)">
            <summary>
            Creates a new file from a byte array and a name.
            </summary>
            <param name="name">The file's name, ideally with an extension. The file name
            must begin with an alphanumeric character, and consist of alphanumeric
            characters, periods, spaces, underscores, or dashes.</param>
            <param name="data">The file's data.</param>
            <param name="mimeType">To specify the content-type used when uploading the
            file, provide this parameter.</param>
        </member>
        <member name="M:Parse.ParseFile.#ctor(System.String,System.IO.Stream,System.String)">
            <summary>
            Creates a new file from a stream and a name.
            </summary>
            <param name="name">The file's name, ideally with an extension. The file name
            must begin with an alphanumeric character, and consist of alphanumeric
            characters, periods, spaces, underscores, or dashes.</param>
            <param name="data">The file's data.</param>
            <param name="mimeType">To specify the content-type used when uploading the
            file, provide this parameter.</param>
        </member>
        <member name="M:Parse.ParseFile.SaveAsync">
            <summary>
            Saves the file to the Parse cloud.
            </summary>
        </member>
        <member name="M:Parse.ParseFile.SaveAsync(System.Threading.CancellationToken)">
            <summary>
            Saves the file to the Parse cloud.
            </summary>
            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.ParseFile.SaveAsync(System.IProgress{Parse.ParseUploadProgressEventArgs})">
            <summary>
            Saves the file to the Parse cloud.
            </summary>
            <param name="progress">The progress callback.</param>
        </member>
        <member name="M:Parse.ParseFile.SaveAsync(System.IProgress{Parse.ParseUploadProgressEventArgs},System.Threading.CancellationToken)">
            <summary>
            Saves the file to the Parse cloud.
            </summary>
            <param name="progress">The progress callback.</param>
            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="P:Parse.ParseFile.IsDirty">
            <summary>
            Gets whether the file still needs to be saved.
            </summary>
        </member>
        <member name="P:Parse.ParseFile.Name">
            <summary>
            Gets the name of the file.  Before save is called, this is the filename given by
            the user.  After save is called, that name gets prefixed with a unique identifier.
            </summary>
        </member>
        <member name="P:Parse.ParseFile.MimeType">
            <summary>
            Gets the MIME type of the file.  This is either passed in to the constructor or
            inferred from the file extension.  "unknown/unknown" will be used if neither is 
            available.
            </summary>
        </member>
        <member name="P:Parse.ParseFile.Url">
            <summary>
            Gets the url of the file.  It is only available after you save the file or after
            you get the file from a <see cref="T:Parse.ParseObject"/>.
            </summary>
        </member>
        <member name="T:Parse.ParsePushNotificationEventArgs">
            <summary>
            A wrapper around Parse push notification payload.
            </summary>
        </member>
        <member name="P:Parse.ParsePushNotificationEventArgs.Payload">
            <summary>
            The payload of the push notification as <c>IDictionary</c>.
            </summary>
        </member>
        <member name="P:Parse.ParsePushNotificationEventArgs.StringPayload">
            <summary>
            The payload of the push notification as <c>string</c>.
            </summary>
        </member>
        <member name="T:Parse.ParseQueryExtensions">
            <summary>
            Provides extension methods for <see cref="T:Parse.ParseQuery`1"/> to support
            Linq-style queries.
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.GetMethod``1(System.Linq.Expressions.Expression{System.Action{``0}})">
            <summary>
            Gets a MethodInfo for a top-level method call.
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.ContainsStub``1(System.Object,``0)">
            <summary>
            When a query is normalized, this is a placeholder to indicate we should
            add a WhereContainedIn() clause.
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.NotContainsStub``1(System.Object,``0)">
            <summary>
            When a query is normalized, this is a placeholder to indicate we should
            add a WhereNotContainedIn() clause.
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.ContainsKeyStub(Parse.ParseObject,System.String)">
            <summary>
            When a query is normalized, this is a placeholder to indicate that we should
            add a WhereExists() clause.
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.NotContainsKeyStub(Parse.ParseObject,System.String)">
            <summary>
            When a query is normalized, this is a placeholder to indicate that we should
            add a WhereDoesNotExist() clause.
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.GetValue(System.Linq.Expressions.Expression)">
            <summary>
            Evaluates an expression and throws if the expression has components that can't be
            evaluated (e.g. uses the parameter that's only represented by an object on the server).
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.IsParseObjectGet(System.Linq.Expressions.MethodCallExpression)">
            <summary>
            Checks whether the MethodCallExpression is a call to ParseObject.Get(),
            which is the call we normalize all indexing into the ParseObject to.
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.WhereMethodCall``1(Parse.ParseQuery{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Linq.Expressions.MethodCallExpression)">
            <summary>
            Converts a normalized method call expression into the appropriate ParseQuery clause.
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.WhereBinaryExpression``1(Parse.ParseQuery{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Linq.Expressions.BinaryExpression)">
            <summary>
            Converts a normalized binary expression into the appropriate ParseQuery clause.
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.Where``1(Parse.ParseQuery{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})">
            <summary>
            Filters a query based upon the predicate provided.
            </summary>
            <typeparam name="TSource">The type of ParseObject being queried for.</typeparam>
            <param name="source">The base <see cref="T:Parse.ParseQuery`1"/> to which
            the predicate will be added.</param>
            <param name="predicate">A function to test each ParseObject for a condition.
            The predicate must be able to be represented by one of the standard Where
            functions on ParseQuery</param>
            <returns>A new ParseQuery whose results will match the given predicate as
            well as the source's filters.</returns>
        </member>
        <member name="M:Parse.ParseQueryExtensions.GetOrderByPath``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})">
            <summary>
            Normalizes an OrderBy's keySelector expression and then extracts the path
            from the ParseObject.Get() call.
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.OrderBy``2(Parse.ParseQuery{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})">
            <summary>
            Orders a query based upon the key selector provided.
            </summary>
            <typeparam name="TSource">The type of ParseObject being queried for.</typeparam>
            <typeparam name="TSelector">The type of key returned by keySelector.</typeparam>
            <param name="source">The query to order.</param>
            <param name="keySelector">A function to extract a key from the ParseObject.</param>
            <returns>A new ParseQuery based on source whose results will be ordered by
            the key specified in the keySelector.</returns>
        </member>
        <member name="M:Parse.ParseQueryExtensions.OrderByDescending``2(Parse.ParseQuery{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})">
            <summary>
            Orders a query based upon the key selector provided.
            </summary>
            <typeparam name="TSource">The type of ParseObject being queried for.</typeparam>
            <typeparam name="TSelector">The type of key returned by keySelector.</typeparam>
            <param name="source">The query to order.</param>
            <param name="keySelector">A function to extract a key from the ParseObject.</param>
            <returns>A new ParseQuery based on source whose results will be ordered by
            the key specified in the keySelector.</returns>
        </member>
        <member name="M:Parse.ParseQueryExtensions.ThenBy``2(Parse.ParseQuery{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})">
            <summary>
            Performs a subsequent ordering of a query based upon the key selector provided.
            </summary>
            <typeparam name="TSource">The type of ParseObject being queried for.</typeparam>
            <typeparam name="TSelector">The type of key returned by keySelector.</typeparam>
            <param name="source">The query to order.</param>
            <param name="keySelector">A function to extract a key from the ParseObject.</param>
            <returns>A new ParseQuery based on source whose results will be ordered by
            the key specified in the keySelector.</returns>
        </member>
        <member name="M:Parse.ParseQueryExtensions.ThenByDescending``2(Parse.ParseQuery{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})">
            <summary>
            Performs a subsequent ordering of a query based upon the key selector provided.
            </summary>
            <typeparam name="TSource">The type of ParseObject being queried for.</typeparam>
            <typeparam name="TSelector">The type of key returned by keySelector.</typeparam>
            <param name="source">The query to order.</param>
            <param name="keySelector">A function to extract a key from the ParseObject.</param>
            <returns>A new ParseQuery based on source whose results will be ordered by
            the key specified in the keySelector.</returns>
        </member>
        <member name="M:Parse.ParseQueryExtensions.Join``4(Parse.ParseQuery{``0},Parse.ParseQuery{``1},System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``1,``2}},System.Linq.Expressions.Expression{System.Func{``0,``1,``3}})">
            <summary>
            Correlates the elements of two queries based on matching keys.
            </summary>
            <typeparam name="TOuter">The type of ParseObjects of the first query.</typeparam>
            <typeparam name="TInner">The type of ParseObjects of the second query.</typeparam>
            <typeparam name="TKey">The type of the keys returned by the key selector
            functions.</typeparam>
            <typeparam name="TResult">The type of the result. This must match either
            TOuter or TInner</typeparam>
            <param name="outer">The first query to join.</param>
            <param name="inner">The query to join to the first query.</param>
            <param name="outerKeySelector">A function to extract a join key from the results of
            the first query.</param>
            <param name="innerKeySelector">A function to extract a join key from the results of
            the second query.</param>
            <param name="resultSelector">A function to select either the outer or inner query
            result to determine which query is the base query.</param>
            <returns>A new ParseQuery with a WhereMatchesQuery or WhereMatchesKeyInQuery
            clause based upon the query indicated in the <paramref name="resultSelector"/>.</returns>
        </member>
        <member name="T:Parse.ParseQueryExtensions.ObjectNormalizer">
            <summary>
            Visits an Expression, converting ParseObject.Get/ParseObject[]/ParseObject.Property,
            and nested indices into a single call to ParseObject.Get() with a "field path" like
            "foo.bar.baz"
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.ObjectNormalizer.VisitMember(System.Linq.Expressions.MemberExpression)">
            <summary>
            Check for a ParseFieldName attribute and use that as the path component, turning
            properties like foo.ObjectId into foo.Get("objectId")
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.ObjectNormalizer.VisitUnary(System.Linq.Expressions.UnaryExpression)">
            <summary>
            If a ParseObject.Get() call has been cast, just change the generic parameter.
            </summary>
        </member>
        <member name="T:Parse.ParseQueryExtensions.WhereNormalizer">
            <summary>
            Normalizes Where expressions.
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.WhereNormalizer.VisitBinary(System.Linq.Expressions.BinaryExpression)">
            <summary>
            Normalizes binary operators.  &lt;, &gt;, &lt;=, &gt;= !=, and ==
            This puts the ParseObject.Get() on the left side of the operation
            (reversing it if necessary), and normalizes the ParseObject.Get()
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.WhereNormalizer.VisitUnary(System.Linq.Expressions.UnaryExpression)">
            <summary>
            If a ! operator is used, this removes the ! and instead calls the equivalent
            function (so e.g. == becomes !=, &lt; becomes &gt;=, Contains becomes NotContains)
            </summary>
        </member>
        <member name="M:Parse.ParseQueryExtensions.WhereNormalizer.VisitMethodCall(System.Linq.Expressions.MethodCallExpression)">
            <summary>
            Normalizes .Equals into == and Contains() into the appropriate stub.
            </summary>
        </member>
        <member name="T:Parse.ParseACL">
            <summary>
            A ParseACL is used to control which users and roles can access or modify a particular object.  Each
            <see cref="T:Parse.ParseObject"/> can have its own ParseACL.  You can grant read and write permissions
            separately to specific users, to groups of users that belong to roles, or you can grant permissions
            to "the public" so that, for example, any user could read a particular object but only a particular
            set of users could write to that object.
            </summary>
        </member>
        <member name="M:Parse.ParseACL.#ctor">
            <summary>
            Creates an ACL with no permissions granted.
            </summary>
        </member>
        <member name="M:Parse.ParseACL.#ctor(Parse.ParseUser)">
            <summary>
            Creates an ACL where only the provided user has access.
            </summary>
            <param name="owner">The only user that can read or write objects governed by this ACL.</param>
        </member>
        <member name="M:Parse.ParseACL.SetReadAccess(System.String,System.Boolean)">
            <summary>
            Sets whether the given user id is allowed to read this object.
            </summary>
            <param name="userId">The objectId of the user.</param>
            <param name="allowed">Whether the user has permission.</param>
        </member>
        <member name="M:Parse.ParseACL.SetReadAccess(Parse.ParseUser,System.Boolean)">
            <summary>
            Sets whether the given user is allowed to read this object.
            </summary>
            <param name="user">The user.</param>
            <param name="allowed">Whether the user has permission.</param>
        </member>
        <member name="M:Parse.ParseACL.SetWriteAccess(System.String,System.Boolean)">
            <summary>
            Sets whether the given user id is allowed to write this object.
            </summary>
            <param name="userId">The objectId of the user.</param>
            <param name="allowed">Whether the user has permission.</param>
        </member>
        <member name="M:Parse.ParseACL.SetWriteAccess(Parse.ParseUser,System.Boolean)">
            <summary>
            Sets whether the given user is allowed to write this object.
            </summary>
            <param name="user">The user.</param>
            <param name="allowed">Whether the user has permission.</param>
        </member>
        <member name="M:Parse.ParseACL.GetReadAccess(System.String)">
            <summary>
            Gets whether the given user id is *explicitly* allowed to read this object.
            Even if this returns false, the user may still be able to read it if
            PublicReadAccess is true or a role that the user belongs to has read access.
            </summary>
            <param name="userId">The user objectId to check.</param>
            <returns>Whether the user has access.</returns>
        </member>
        <member name="M:Parse.ParseACL.GetReadAccess(Parse.ParseUser)">
            <summary>
            Gets whether the given user is *explicitly* allowed to read this object.
            Even if this returns false, the user may still be able to read it if
            PublicReadAccess is true or a role that the user belongs to has read access.
            </summary>
            <param name="user">The user to check.</param>
            <returns>Whether the user has access.</returns>
        </member>
        <member name="M:Parse.ParseACL.GetWriteAccess(System.String)">
            <summary>
            Gets whether the given user id is *explicitly* allowed to write this object.
            Even if this returns false, the user may still be able to write it if
            PublicReadAccess is true or a role that the user belongs to has write access.
            </summary>
            <param name="userId">The user objectId to check.</param>
            <returns>Whether the user has access.</returns>
        </member>
        <member name="M:Parse.ParseACL.GetWriteAccess(Parse.ParseUser)">
            <summary>
            Gets whether the given user is *explicitly* allowed to write this object.
            Even if this returns false, the user may still be able to write it if
            PublicReadAccess is true or a role that the user belongs to has write access.
            </summary>
            <param name="user">The user to check.</param>
            <returns>Whether the user has access.</returns>
        </member>
        <member name="M:Parse.ParseACL.SetRoleReadAccess(System.String,System.Boolean)">
            <summary>
            Sets whether users belonging to the role with the given <paramref name="roleName"/>
            are allowed to read this object.
            </summary>
            <param name="roleName">The name of the role.</param>
            <param name="allowed">Whether the role has access.</param>
        </member>
        <member name="M:Parse.ParseACL.SetRoleReadAccess(Parse.ParseRole,System.Boolean)">
            <summary>
            Sets whether users belonging to the given role are allowed to read this object.
            </summary>
            <param name="role">The role.</param>
            <param name="allowed">Whether the role has access.</param>
        </member>
        <member name="M:Parse.ParseACL.GetRoleReadAccess(System.String)">
            <summary>
            Gets whether users belonging to the role with the given <paramref name="roleName"/>
            are allowed to read this object. Even if this returns false, the role may still be
            able to read it if a parent role has read access.
            </summary>
            <param name="roleName">The name of the role.</param>
            <returns>Whether the role has access.</returns>
        </member>
        <member name="M:Parse.ParseACL.GetRoleReadAccess(Parse.ParseRole)">
            <summary>
            Gets whether users belonging to the role are allowed to read this object.
            Even if this returns false, the role may still be able to read it if a
            parent role has read access.
            </summary>
            <param name="role">The name of the role.</param>
            <returns>Whether the role has access.</returns>
        </member>
        <member name="M:Parse.ParseACL.SetRoleWriteAccess(System.String,System.Boolean)">
            <summary>
            Sets whether users belonging to the role with the given <paramref name="roleName"/>
            are allowed to write this object.
            </summary>
            <param name="roleName">The name of the role.</param>
            <param name="allowed">Whether the role has access.</param>
        </member>
        <member name="M:Parse.ParseACL.SetRoleWriteAccess(Parse.ParseRole,System.Boolean)">
            <summary>
            Sets whether users belonging to the given role are allowed to write this object.
            </summary>
            <param name="role">The role.</param>
            <param name="allowed">Whether the role has access.</param>
        </member>
        <member name="M:Parse.ParseACL.GetRoleWriteAccess(System.String)">
            <summary>
            Gets whether users belonging to the role with the given <paramref name="roleName"/>
            are allowed to write this object. Even if this returns false, the role may still be
            able to write it if a parent role has write access.
            </summary>
            <param name="roleName">The name of the role.</param>
            <returns>Whether the role has access.</returns>
        </member>
        <member name="M:Parse.ParseACL.GetRoleWriteAccess(Parse.ParseRole)">
            <summary>
            Gets whether users belonging to the role are allowed to write this object.
            Even if this returns false, the role may still be able to write it if a
            parent role has write access.
            </summary>
            <param name="role">The name of the role.</param>
            <returns>Whether the role has access.</returns>
        </member>
        <member name="P:Parse.ParseACL.PublicReadAccess">
            <summary>
            Gets or sets whether the public is allowed to read this object.
            </summary>
        </member>
        <member name="P:Parse.ParseACL.PublicWriteAccess">
            <summary>
            Gets or sets whether the public is allowed to write this object.
            </summary>
        </member>
        <member name="T:Parse.ParseClient">
            <summary>
            ParseClient contains static functions that handle global
            configuration for the Parse library.
            </summary>
        </member>
        <member name="M:Parse.ParseClient.Initialize(System.String,System.String)">
            <summary>
            Authenticates this client as belonging to your application. This must be
            called before your application can use the Parse library. The recommended
            way is to put a call to <c>ParseFramework.Initialize</c> in your
            Application startup.
            </summary>
            <param name="applicationId">The Application ID provided in the Parse dashboard.
            </param>
            <param name="dotnetKey">The .NET API Key provided in the Parse dashboard.
            </param>
        </member>
        <member name="M:Parse.ParseClient.RequestAsync(System.String,System.String,System.String,System.Collections.Generic.IDictionary{System.String,System.Object},System.Threading.CancellationToken)">
            <summary>
            Convenience alias for RequestAsync that takes a string instead of a Uri.
            </summary>
        </member>
        <member name="M:Parse.ParseClient.RequestAsync(System.String,System.Uri,System.String,System.Collections.Generic.IDictionary{System.String,System.Object},System.Threading.CancellationToken)">
            <summary>
            The main mechanism for making requests to Parse. Attaches headers related to
            the SDK, session token, etc., then JSON-parses the result of the request and throws
            a ParseException if necessary.
            </summary>
            <param name="method">The HTTP method to use.</param>
            <param name="relativeUri">A relative URI for the API.</param>
            <param name="cancellationToken">The session token for the request.</param>
            <param name="data">A JSON-style data object that will be stringified
            for the request body.</param>
            <param name="sessionToken">The cancellation token for the request.</param>
            <returns>A tuple indicating the HTTP status code and the JSON data
            returned by the request.</returns>
        </member>
        <member name="M:Parse.ParseClient.UploadAsync(System.Uri,System.String,System.String,System.IO.Stream,System.IProgress{Parse.ParseUploadProgressEventArgs},System.Threading.CancellationToken)">
            <summary>
            Performs an upload that reports progress.
            </summary>
        </member>
        <member name="M:Parse.ParseClient.As``1(System.Object)">
            <summary>
            Performs a ConvertTo, but returns null if the object can't be
            converted to that type.
            </summary>
        </member>
        <member name="M:Parse.ParseClient.ConvertTo``1(System.Object)">
            <summary>
            Converts a value to the requested type -- coercing primitives to
            the desired type, wrapping lists and dictionaries appropriately,
            or else passing the object along to the caller unchanged.
            
            This should be used on any containers that might be coming from a
            user to normalize the collection types.  Collection types coming from
            JSON deserialization can be safely assumed to be lists or dictionaries of
            objects.
            </summary>
        </member>
        <member name="F:Parse.ParseClient.interfaceLookupCache">
            <summary>
            Holds a dictionary that maps a cache of interface types for related concrete types.
            The lookup is slow the first time for each type because it has to enumerate all interface
            on the object type, but made fast by the cache.
            
            The map is:
               (object type, generic interface type) => constructed generic type
            </summary>
        </member>
        <member name="M:Parse.ParseClient.DeepTraversal(System.Object,System.Boolean,System.Boolean)">
            <summary>
            Flattens dictionaries and l