text:
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Parse</name>
    </assembly>
    <members>
        <member name="M:Parse.Internal.IParseCommandRunner.RunCommandAsync(Parse.Internal.ParseCommand,System.IProgress{Parse.ParseUploadProgressEventArgs},System.IProgress{Parse.ParseDownloadProgressEventArgs},System.Threading.CancellationToken)">

            Executes <see cref="T:Parse.Internal.ParseCommand"/> and convert the result into Dictionary.

            <param name="command">The command to be run.</param>
            <param name="uploadProgress">Upload progress callback.</param>
            <param name="downloadProgress">Download progress callback.</param>
            <param name="cancellationToken">The cancellation token for the request.</param>
            <returns></returns>
        </member>
        <member name="T:Parse.Internal.ParseCommand">

            ParseCommand is an <see cref="T:Parse.Internal.HttpRequest"/> with pre-populated
            headers.

        </member>
        <member name="M:Parse.Internal.FacebookAuthenticationProvider.TryParseOAuthCallbackUrl(System.Uri,System.Collections.Generic.IDictionary{System.String,System.String}@)">

            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)

        </member>
        <member name="T:Parse.Internal.FlexibleDictionaryWrapper`2">

            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.

            <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">

            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.

            <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">

            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.

        </member>
        <member name="M:Parse.Internal.IHttpClient.ExecuteAsync(Parse.Internal.HttpRequest,System.IProgress{Parse.ParseUploadProgressEventArgs},System.IProgress{Parse.ParseDownloadProgressEventArgs},System.Threading.CancellationToken)">

            Executes HTTP request to a <see cref="P:Parse.Internal.HttpRequest.Uri"/> with <see cref="P:Parse.Internal.HttpRequest.Method"/> HTTP verb
            and <see cref="P:Parse.Internal.HttpRequest.Headers"/>.

            <param name="httpRequest">The HTTP request to be executed.</param>
            <param name="uploadProgress">Upload progress callback.</param>
            <param name="downloadProgress">Download progress callback.</param>
            <param name="cancellationToken">The cancellation token.</param>
            <returns>A task that resolves to Htt</returns>
        </member>
        <member name="T:Parse.Internal.HttpRequest">

            IHttpRequest is an interface that provides an API to execute HTTP request data.

        </member>
        <member name="P:Parse.Internal.HttpRequest.Data">

            Data stream to be uploaded.

        </member>
        <member name="P:Parse.Internal.HttpRequest.Method">

            HTTP method. One of <c>DELETE</c>, <c>GET</c>, <c>HEAD</c>, <c>POST</c> or <c>PUT</c>

        </member>
        <member name="T:Parse.Internal.IJsonConvertible">

            Represents an object that can be converted into JSON.

        </member>
        <member name="M:Parse.Internal.IJsonConvertible.ToJSON">

            Converts the object to a data structure that can be converted to JSON.

            <returns>An object to be JSONified.</returns>
        </member>
        <member name="M:Parse.Internal.IInstallationIdController.Set(System.Nullable{System.Guid})">

            Sets current installationId and saves it to local storage.

            <param name="installationId">The installationId to be saved.</param>
        </member>
        <member name="M:Parse.Internal.IInstallationIdController.Get">

            Gets current installationId from local storage. Generates a none exists.

            <returns>Current installationid.</returns>
        </member>
        <member name="M:Parse.Internal.IInstallationIdController.Clear">

            Clears current installationId from memory and local storage.

        </member>
        <member name="T:Parse.Internal.InternalExtensions">

            Provides helper methods that allow us to use terser code elsewhere.

        </member>
        <member name="M:Parse.Internal.InternalExtensions.Safe``1(System.Threading.Tasks.Task{``0})">

            Ensures a task (even null) is awaitable.

            <typeparam name="T"></typeparam>
            <param name="task"></param>
            <returns></returns>
        </member>
        <member name="M:Parse.Internal.InternalExtensions.Safe(System.Threading.Tasks.Task)">

            Ensures a task (even null) is awaitable.

            <param name="task"></param>
            <returns></returns>
        </member>
        <member name="M:Parse.Internal.InternalExtensions.GetPartial``1(Parse.ParseObject,Parse.Internal.InternalExtensions.PartialAccessor{``0})">

            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<string>(GetFoo);

            <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}})">

            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<string> task)
            we can say string foo = await PartialAsync<string>(FooAsync);

            <typeparam name="T"></typeparam>
            <param name="self"></param>
            <param name="partial"></param>
            <returns></returns>
        </member>
        <member name="M:Parse.Internal.IParseAuthenticationProvider.AuthenticateAsync(System.Threading.CancellationToken)">

            Authenticates with the service.

            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.Internal.IParseAuthenticationProvider.Deauthenticate">

            Deauthenticates (logs out) the user associated with this provider. This
            call may block.

        </member>
        <member name="M:Parse.Internal.IParseAuthenticationProvider.RestoreAuthentication(System.Collections.Generic.IDictionary{System.String,System.Object})">

            Restores authentication that has been serialized, such as session keys,
            etc.

            <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">

            Provides a unique name for the type of authentication the provider does.
            For example, the FacebookAuthenticationProvider would return "facebook".

        </member>
        <member name="T:Parse.Internal.IParseFieldOperation">

            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.

        </member>
        <member name="M:Parse.Internal.IParseFieldOperation.Encode">

            Converts the ParseFieldOperation to a data structure that can be converted to JSON and sent to
            Parse as part of a save operation.

            <returns>An object to be JSONified.</returns>
        </member>
        <member name="M:Parse.Internal.IParseFieldOperation.MergeWithPrevious(Parse.Internal.IParseFieldOperation)">

            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
            this 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}        ///
            <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,System.String)">

            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.

            <param name="oldValue">The previous value for the field.</param>
            <param name="key">The key that this value is for.</param>
            <returns>The new value for the field.</returns>
        </member>
        <member name="P:Parse.Internal.IPlatformHooks.ApplicationSettings">

            A thread-safe dictionary that persists key-value pair objects to disk.

        </member>
        <member name="M:Parse.Internal.IPlatformHooks.ExecuteParseInstallationSaveHookAsync(Parse.ParseInstallation)">

            Executes platform specific hook that mutate the installation based on
            the device platforms.

            <param name="installation">Installation to be mutated.</param>
            <returns></returns>
        </member>
        <member name="T:Parse.Internal.Json">

            A simple recursive-descent JSON Parser based on the grammar defined at http://www.json.org
            and http://tools.ietf.org/html/rfc4627

        </member>
        <member name="F:Parse.Internal.Json.startOfString">

            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).

        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.ParseObject(System.Object@)">

            Parses JSON object syntax (e.g. '{}')

        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.ParseMember(System.Object@)">

            Parses JSON member syntax (e.g. '"keyname" : null')

        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.ParseArray(System.Object@)">

            Parses JSON array syntax (e.g. '[]')

        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.ParseValue(System.Object@)">

            Parses a value (i.e. the right-hand side of an object member assignment or
            an element in an array)

        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.ParseString(System.Object@)">

            Parses a JSON string (e.g. '"foo\u1234bar\n"')

        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.ParseNumber(System.Object@)">

            Parses a number. Returns a long if the number is an integer or has an exponent,
            otherwise returns a double.

        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.Accept(System.Text.RegularExpressions.Regex,System.Text.RegularExpressions.Match@)">

            Matches the string to a regex, consuming part of the string and returning the match.

        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.Accept(System.Char)">

            Find the first occurences of a character, consuming part of the string.

        </member>
        <member name="M:Parse.Internal.Json.JsonStringParser.Accept(System.Char[])">

            Find the first occurences of a string, consuming part of the string.

        </member>
        <member name="M:Parse.Internal.Json.Parse(System.String)">

            Parses a JSON-text as defined in http://tools.ietf.org/html/rfc4627, returning an
            IDictionary<string, object> or an IList<object> depending on whether
            the value was an array or dictionary. Nested objects also match these types.

        </member>
        <member name="M:Parse.Internal.Json.Encode(System.Collections.Generic.IDictionary{System.String,System.Object})">

            Encodes a dictionary into a JSON string. Supports values that are
            IDictionary<string, object>, IList<object>, strings,
            nulls, and any of the primitive types.

        </member>
        <member name="M:Parse.Internal.Json.Encode(System.Collections.Generic.IList{System.Object})">

            Encodes a list into a JSON string. Suppots values that are
            IDictionary<string, object>, IList<object>, strings,
            nulls, and any of the primitive types.

        </member>
        <member name="M:Parse.Internal.Json.Encode(System.Object)">

            Encodes an object into a JSON string.

        </member>
        <member name="T:Parse.Internal.NoObjectsEncoder">

            A <see cref="T:Parse.Internal.ParseEncoder"/> that throws an exception if it attempts to encode
            a <see cref="T:Parse.ParseObject"/>

        </member>
        <member name="T:Parse.Internal.IParseObjectCurrentController`1">

            IParseObjectCurrentController controls the single-instance <see cref="T:Parse.ParseObject"/>
            persistence used throughout the code-base. Sample usages are <see cref="P:Parse.ParseUser.CurrentUser"/> and
            <see cref="P:Parse.ParseInstallation.CurrentInstallation"/>.

            <typeparam name="T">Type of object being persisted.</typeparam>
        </member>
        <member name="M:Parse.Internal.IParseObjectCurrentController`1.SetAsync(`0,System.Threading.CancellationToken)">

            Persists current <see cref="T:Parse.ParseObject"/>.

            <param name="obj"><see cref="T:Parse.ParseObject"/> to be persisted.</param>
            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.Internal.IParseObjectCurrentController`1.GetAsync(System.Threading.CancellationToken)">

            Gets the persisted current <see cref="T:Parse.ParseObject"/>.

            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.Internal.IParseObjectCurrentController`1.ExistsAsync(System.Threading.CancellationToken)">

            Returns a <see cref="T:System.Threading.Tasks.Task"/> that resolves to true if current
            <see cref="T:Parse.ParseObject"/> exists.

            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.Internal.IParseObjectCurrentController`1.IsCurrent(`0)">

            Returns true if the given <see cref="T:Parse.ParseObject"/> is the persisted current
            <see cref="T:Parse.ParseObject"/>.

            <param name="obj">The object to check.</param>
            <returns>True if obj is the current persisted <see cref="T:Parse.ParseObject"/>.</returns>
        </member>
        <member name="M:Parse.Internal.IParseObjectCurrentController`1.ClearFromMemory">

            Nullifies the current <see cref="T:Parse.ParseObject"/> from memory.

        </member>
        <member name="M:Parse.Internal.IParseObjectCurrentController`1.ClearFromDisk">

            Clears current <see cref="T:Parse.ParseObject"/> from disk.

        </member>
        <member name="T:Parse.Internal.ParseDeleteOperation">

            An operation where a field is deleted from the object.

        </member>
        <member name="T:Parse.Internal.ParseEncoder">

            A <c>ParseEncoder</c> can be used to transform objects such as <see cref="T:Parse.ParseObject"/> into JSON
            data structures.

            <seealso cref="T:Parse.Internal.ParseDecoder"/>
        </member>
        <member name="T:Parse.Internal.PointerOrLocalIdEncoder">

            A <see cref="T:Parse.Internal.ParseEncoder"/> that encode <see cref="T:Parse.ParseObject"/> as pointers. If the object
            does not have an <see cref="P:Parse.ParseObject.ObjectId"/>, uses a local id.

        </member>
        <member name="M:Parse.Internal.ReflectionHelpers.FindConstructor(System.Type,System.Type[])">

            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.

            <param name="self"></param>
            <param name="parameterTypes"></param>
            <returns></returns>
        </member>
        <member name="T:Parse.Internal.SynchronizedEventHandler`1">

            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>

        </member>
        <member name="T:Parse.Internal.TaskQueue">

            A helper class for enqueuing tasks

        </member>
        <member name="F:Parse.Internal.TaskQueue.tail">

            We only need to keep the tail of the queue. Cancelled tasks will
            just complete normally/immediately when their turn arrives.

        </member>
        <member name="M:Parse.Internal.TaskQueue.GetTaskToAwait(System.Threading.CancellationToken)">

            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.

            <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)">

            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.

            <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="P:Parse.Internal.IParseConfigController.CurrentConfigController">

            Gets the current config controller.

            <value>The current config controller.</value>
        </member>
        <member name="M:Parse.Internal.IParseConfigController.FetchConfigAsync(System.String,System.Threading.CancellationToken)">

            Fetchs the config from the server asynchrounously.

            <returns>The config async.</returns>
            <param name="sessionToken">Session token.</param>
            <param name="cancellationToken">Cancellation token.</param>
        </member>
        <member name="T:Parse.Internal.ParseConfigController">

            Config controller.

        </member>
        <member name="M:Parse.Internal.ParseConfigController.#ctor">

            Initializes a new instance of the <see cref="T:Parse.Internal.ParseConfigController"/> class.

        </member>
        <member name="M:Parse.Internal.IParseCurrentConfigController.GetCurrentConfigAsync">

            Gets the current config async.

            <returns>The current config async.</returns>
        </member>
        <member name="M:Parse.Internal.IParseCurrentConfigController.SetCurrentConfigAsync(Parse.ParseConfig)">

            Sets the current config async.

            <returns>The current config async.</returns>
            <param name="config">Config.</param>
        </member>
        <member name="M:Parse.Internal.IParseCurrentConfigController.ClearCurrentConfigAsync">

            Clears the current config async.

            <returns>The current config async.</returns>
        </member>
        <member name="M:Parse.Internal.IParseCurrentConfigController.ClearCurrentConfigInMemoryAsync">

            Clears the current config in memory async.

            <returns>The current config in memory async.</returns>
        </member>
        <member name="T:Parse.Internal.ParseCurrentConfigController">

            Parse current config controller.

        </member>
        <member name="M:Parse.Internal.ParseCurrentConfigController.#ctor">

            Initializes a new instance of the <see cref="T:Parse.Internal.ParseCurrentConfigController"/> class.

        </member>
        <member name="T:Parse.ParseConfig">

            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".

        </member>
        <member name="P:Parse.ParseConfig.CurrentConfig">

            Gets the latest fetched ParseConfig.

            <returns>ParseConfig object</returns>
        </member>
        <member name="M:Parse.ParseConfig.GetAsync">

            Retrieves the ParseConfig asynchronously from the server.

            <returns>ParseConfig object that was fetched</returns>
        </member>
        <member name="M:Parse.ParseConfig.GetAsync(System.Threading.CancellationToken)">

            Retrieves the ParseConfig asynchronously from the server.

            <param name="cancellationToken">The cancellation token.</param>
            <returns>ParseConfig object that was fetched</returns>
        </member>
        <member name="M:Parse.ParseConfig.Get``1(System.String)">

            Gets a value for the key of a particular type.

            <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<T>, IDictionary<string, T> 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@)">

            Populates result with the value for the key, if possible.

            <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.Item(System.String)">

            Gets a value on the config.

            <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">

            Specifies a field name for a property on a ParseObject subclass.

        </member>
        <member name="M:Parse.ParseFieldNameAttribute.#ctor(System.String)">

            Constructs a new ParseFieldName attribute.

            <param name="fieldName">The name of the field on the ParseObject that the
            property represents.</param>
        </member>
        <member name="P:Parse.ParseFieldNameAttribute.FieldName">

            Gets the name of the field represented by this property.

        </member>
        <member name="T:Parse.ParseClassNameAttribute">

            Defines the class name for a subclass of ParseObject.

        </member>
        <member name="M:Parse.ParseClassNameAttribute.#ctor(System.String)">

            Constructs a new ParseClassName attribute.

            <param name="className">The class name to associate with the ParseObject subclass.</param>
        </member>
        <member name="P:Parse.ParseClassNameAttribute.ClassName">

            Gets the class name to associate with the ParseObject subclass.

        </member>
        <member name="T:Parse.ParseFile">

            ParseFile is a local representation of a file that is saved to the Parse cloud.

            <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:

            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();

            </example>
        </member>
        <member name="M:Parse.ParseFile.#ctor(System.String,System.Byte[],System.String)">

            Creates a new file from a byte array and a name.

            <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)">

            Creates a new file from a stream and a name.

            <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="P:Parse.ParseFile.IsDirty">

            Gets whether the file still needs to be saved.

        </member>
        <member name="P:Parse.ParseFile.Name">

            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.

        </member>
        <member name="P:Parse.ParseFile.MimeType">

            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.

        </member>
        <member name="P:Parse.ParseFile.Url">

            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"/>.

        </member>
        <member name="M:Parse.ParseFile.SaveAsync">

            Saves the file to the Parse cloud.

        </member>
        <member name="M:Parse.ParseFile.SaveAsync(System.Threading.CancellationToken)">

            Saves the file to the Parse cloud.

            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.ParseFile.SaveAsync(System.IProgress{Parse.ParseUploadProgressEventArgs})">

            Saves the file to the Parse cloud.

            <param name="progress">The progress callback.</param>
        </member>
        <member name="M:Parse.ParseFile.SaveAsync(System.IProgress{Parse.ParseUploadProgressEventArgs},System.Threading.CancellationToken)">

            Saves the file to the Parse cloud.

            <param name="progress">The progress callback.</param>
            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="T:Parse.ParseDownloadProgressEventArgs">

            Represents download progress.

        </member>
        <member name="P:Parse.ParseDownloadProgressEventArgs.Progress">

            Gets the progress (a number between 0.0 and 1.0) of a download.

        </member>
        <member name="T:Parse.ParseInstallation">

             Represents this app installed on this device. Use this class to track infomation you want
             to sample from (i.e. if you update a field on app launch, you can issue a query to see
             the number of devices which were active in the last N hours).

        </member>
        <member name="M:Parse.ParseInstallation.#ctor">

            Constructs a new ParseInstallation. Generally, you should not need to construct
            ParseInstallations yourself. Instead use <see cref="P:Parse.ParseInstallation.CurrentInstallation"/>.

        </member>
        <member name="P:Parse.ParseInstallation.CurrentInstallation">

            Gets the ParseInstallation representing this app on this device.

        </member>
        <member name="P:Parse.ParseInstallation.Query">

            Constructs a <see cref="T:Parse.ParseQuery`1"/> for ParseInstallations.

            <remarks>
            Only the following types of queries are allowed for installations:

            query.GetAsync(objectId)
            query.WhereEqualTo(key, value)
            query.WhereMatchesKeyInQuery<TOther>(key, keyInQuery, otherQuery)

            You can add additional query conditions, but one of the above must appear as a top-level <c>AND</c>
            clause in the query.
            </remarks>
        </member>
        <member name="P:Parse.ParseInstallation.InstallationId">

            A GUID that uniquely names this app installed on this device.

        </member>
        <member name="P:Parse.ParseInstallation.DeviceType">

            The runtime target of this installation object.

        </member>
        <member name="P:Parse.ParseInstallation.AppName">

            The user-friendly display name of this application.

        </member>
        <member name="P:Parse.ParseInstallation.AppVersion">

            A version string consisting of Major.Minor.Build.Revision.

        </member>
        <member name="P:Parse.ParseInstallation.AppIdentifier">

            The system-dependent unique identifier of this installation. This identifier should be
            sufficient to distinctly name an app on stores which may allow multiple apps with the
            same display name.

        </member>
        <member name="P:Parse.ParseInstallation.TimeZone">

            The time zone in which this device resides. This string is in the tz database format
            Parse uses for local-time pushes. Due to platform restrictions, the mapping is less
            granular on Windows than it may be on other systems. E.g. The zones
            America/Vancouver America/Dawson America/Whitehorse, America/Tijuana, PST8PDT, and
            America/Los_Angeles are all reported as America/Los_Angeles.

        </member>
        <member name="P:Parse.ParseInstallation.LocaleIdentifier">

            The users locale. This field gets automatically populated by the SDK.
            Can be null (Parse Push uses default language in this case).

        </member>
        <member name="M:Parse.ParseInstallation.GetLocaleIdentifier">

            Gets the locale identifier in the format: [language code]-[COUNTRY CODE].

            <returns>The locale identifier in the format: [language code]-[COUNTRY CODE].</returns>
        </member>
        <member name="P:Parse.ParseInstallation.ParseVersion">

            The version of the Parse SDK used to build this application.

        </member>
        <member name="P:Parse.ParseInstallation.Channels">

            A sequence of arbitrary strings which are used to identify this installation for push notifications.
            By convention, the empty string is known as the "Broadcast" channel.

        </member>
        <member name="F:Parse.ParseInstallation.TimeZoneNameMap">

            This mapping of Windows names to a standard everyone else uses is maintained
            by the Unicode consortium, which makes this officially the first helpful
            interaction between Unicode and Microsoft.
            Unfortunately this is a little lossy in that we only store the first mapping in each zone because
            Microsoft does not give us more granular location information.
            Built from http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/zone_tzid.html

        </member>
        <member name="T:Parse.ParsePushNotificationEventArgs">

            A wrapper around Parse push notification payload.

        </member>
        <member name="P:Parse.ParsePushNotificationEventArgs.Payload">

            The payload of the push notification as <c>IDictionary</c>.

        </member>
        <member name="P:Parse.ParsePushNotificationEventArgs.StringPayload">

            The payload of the push notification as <c>string</c>.

        </member>
        <member name="T:Parse.ParseQueryExtensions">

            Provides extension methods for <see cref="T:Parse.ParseQuery`1"/> to support
            Linq-style queries.

        </member>
        <member name="M:Parse.ParseQueryExtensions.GetMethod``1(System.Linq.Expressions.Expression{System.Action{``0}})">

            Gets a MethodInfo for a top-level method call.

        </member>
        <member name="M:Parse.ParseQueryExtensions.ContainsStub``1(System.Object,``0)">

            When a query is normalized, this is a placeholder to indicate we should
            add a WhereContainedIn() clause.

        </member>
        <member name="M:Parse.ParseQueryExtensions.NotContainsStub``1(System.Object,``0)">

            When a query is normalized, this is a placeholder to indicate we should
            add a WhereNotContainedIn() clause.

        </member>
        <member name="M:Parse.ParseQueryExtensions.ContainsKeyStub(Parse.ParseObject,System.String)">

            When a query is normalized, this is a placeholder to indicate that we should
            add a WhereExists() clause.

        </member>
        <member name="M:Parse.ParseQueryExtensions.NotContainsKeyStub(Parse.ParseObject,System.String)">

            When a query is normalized, this is a placeholder to indicate that we should
            add a WhereDoesNotExist() clause.

        </member>
        <member name="M:Parse.ParseQueryExtensions.GetValue(System.Linq.Expressions.Expression)">

            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).

        </member>
        <member name="M:Parse.ParseQueryExtensions.IsParseObjectGet(System.Linq.Expressions.MethodCallExpression)">

            Checks whether the MethodCallExpression is a call to ParseObject.Get(),
            which is the call we normalize all indexing into the ParseObject to.

        </member>
        <member name="T:Parse.ParseQueryExtensions.ObjectNormalizer">

            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"

        </member>
        <member name="M:Parse.ParseQueryExtensions.ObjectNormalizer.VisitMember(System.Linq.Expressions.MemberExpression)">

            Check for a ParseFieldName attribute and use that as the path component, turning
            properties like foo.ObjectId into foo.Get("objectId")

        </member>
        <member name="M:Parse.ParseQueryExtensions.ObjectNormalizer.VisitUnary(System.Linq.Expressions.UnaryExpression)">

            If a ParseObject.Get() call has been cast, just change the generic parameter.

        </member>
        <member name="T:Parse.ParseQueryExtensions.WhereNormalizer">

            Normalizes Where expressions.

        </member>
        <member name="M:Parse.ParseQueryExtensions.WhereNormalizer.VisitBinary(System.Linq.Expressions.BinaryExpression)">

            Normalizes binary operators. <, >, <=, >= !=, and ==
            This puts the ParseObject.Get() on the left side of the operation
            (reversing it if necessary), and normalizes the ParseObject.Get()

        </member>
        <member name="M:Parse.ParseQueryExtensions.WhereNormalizer.VisitUnary(System.Linq.Expressions.UnaryExpression)">

            If a ! operator is used, this removes the ! and instead calls the equivalent
            function (so e.g. == becomes !=, < becomes >=, Contains becomes NotContains)

        </member>
        <member name="M:Parse.ParseQueryExtensions.WhereNormalizer.VisitMethodCall(System.Linq.Expressions.MethodCallExpression)">

            Normalizes .Equals into == and Contains() into the appropriate stub.

        </member>
        <member name="M:Parse.ParseQueryExtensions.WhereMethodCall``1(Parse.ParseQuery{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Linq.Expressions.MethodCallExpression)">

            Converts a normalized method call expression into the appropriate ParseQuery clause.

        </member>
        <member name="M:Parse.ParseQueryExtensions.WhereBinaryExpression``1(Parse.ParseQuery{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Linq.Expressions.BinaryExpression)">

            Converts a normalized binary expression into the appropriate ParseQuery clause.

        </member>
        <member name="M:Parse.ParseQueryExtensions.Where``1(Parse.ParseQuery{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})">

            Filters a query based upon the predicate provided.

            <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}})">

            Normalizes an OrderBy's keySelector expression and then extracts the path
            from the ParseObject.Get() call.

        </member>
        <member name="M:Parse.ParseQueryExtensions.OrderBy``2(Parse.ParseQuery{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})">

            Orders a query based upon the key selector provided.

            <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}})">

            Orders a query based upon the key selector provided.

            <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}})">

            Performs a subsequent ordering of a query based upon the key selector provided.

            <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}})">

            Performs a subsequent ordering of a query based upon the key selector provided.

            <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}})">

            Correlates the elements of two queries based on matching keys.

            <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.ParseACL">

            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.

        </member>
        <member name="M:Parse.ParseACL.#ctor">

            Creates an ACL with no permissions granted.

        </member>
        <member name="M:Parse.ParseACL.#ctor(Parse.ParseUser)">

            Creates an ACL where only the provided user has access.

            <param name="owner">The only user that can read or write objects governed by this ACL.</param>
        </member>
        <member name="P:Parse.ParseACL.PublicReadAccess">

            Gets or sets whether the public is allowed to read this object.

        </member>
        <member name="P:Parse.ParseACL.PublicWriteAccess">

            Gets or sets whether the public is allowed to write this object.

        </member>
        <member name="M:Parse.ParseACL.SetReadAccess(System.String,System.Boolean)">

            Sets whether the given user id is allowed to read this object.

            <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)">

            Sets whether the given user is allowed to read this object.

            <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)">

            Sets whether the given user id is allowed to write this object.

            <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)">

            Sets whether the given user is allowed to write this object.

            <param name="user">The user.</param>
            <param name="allowed">Whether the user has permission.</param>
        </member>
        <member name="M:Parse.ParseACL.GetReadAccess(System.String)">

            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.

            <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)">

            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.

            <param name="user">The user to check.</param>
            <returns>Whether the user has access.</returns>
        </member>
        <member name="M:Parse.ParseACL.GetWriteAccess(System.String)">

            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.

            <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)">

            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.

            <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)">

            Sets whether users belonging to the role with the given <paramref name="roleName"/>
            are allowed to read this object.

            <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)">

            Sets whether users belonging to the given role are allowed to read this object.

            <param name="role">The role.</param>
            <param name="allowed">Whether the role has access.</param>
        </member>
        <member name="M:Parse.ParseACL.GetRoleReadAccess(System.String)">

            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.

            <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)">

            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.

            <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)">

            Sets whether users belonging to the role with the given <paramref name="roleName"/>
            are allowed to write this object.

            <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)">

            Sets whether users belonging to the given role are allowed to write this object.

            <param name="role">The role.</param>
            <param name="allowed">Whether the role has access.</param>
        </member>
        <member name="M:Parse.ParseACL.GetRoleWriteAccess(System.String)">

            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.

            <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)">

            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.

            <param name="role">The name of the role.</param>
            <returns>Whether the role has access.</returns>
        </member>
        <member name="T:Parse.ParseClient">

            ParseClient contains static functions that handle global
            configuration for the Parse library.

        </member>
        <member name="M:Parse.ParseClient.Initialize(System.String,System.String)">

            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.

            <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.As``1(System.Object)">

            Performs a ConvertTo, but returns null if the object can't be
            converted to that type.

        </member>
        <member name="M:Parse.ParseClient.ConvertTo``1(System.Object)">

            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.

        </member>
        <member name="F:Parse.ParseClient.interfaceLookupCache">

            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

        </member>
        <member name="T:Parse.ParseCloud">

            The ParseCloud class provides methods for interacting with Parse Cloud Functions.

            <example>
            For example, this sample code calls the
            "validateGame" Cloud Function and calls processResponse if the call succeeded
            and handleError if it failed.

            var result =
                await ParseCloud.CallFunctionAsync<IDictionary<string, object>>("validateGame", parameters);

            </example>
        </member>
        <member name="M:Parse.ParseCloud.CallFunctionAsync``1(System.String,System.Collections.Generic.IDictionary{System.String,System.Object})">

            Calls a cloud function.

            <typeparam name="T">The type of data you will receive from the cloud function. This
            can be an IDictionary, string, IList, ParseObject, or any other type supported by
            ParseObject.</typeparam>
            <param name="name">The cloud function to call.</param>
            <param name="parameters">The parameters to send to the cloud function. This
            dictionary can contain anything that could be passed into a ParseObject except for
            ParseObjects themselves.</param>
            <returns>The result of the cloud call.</returns>
        </member>
        <member name="M:Parse.ParseCloud.CallFunctionAsync``1(System.String,System.Collections.Generic.IDictionary{System.String,System.Object},System.Threading.CancellationToken)">

            Calls a cloud function.

            <typeparam name="T">The type of data you will receive from the cloud function. This
            can be an IDictionary, string, IList, ParseObject, or any other type supported by
            ParseObject.</typeparam>
            <param name="name">The cloud function to call.</param>
            <param name="parameters">The parameters to send to the cloud function. This
            dictionary can contain anything that could be passed into a ParseObject except for
            ParseObjects themselves.</param>
            <param name="cancellationToken">The cancellation token.</param>
            <returns>The result of the cloud call.</returns>
        </member>
        <member name="T:Parse.ParseException">

            Exceptions that may occur when sending requests to Parse.

        </member>
        <member name="T:Parse.ParseException.ErrorCode">

            Error codes that may be delivered in response to requests to Parse.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.OtherCause">

            Error code indicating that an unknown error or an error unrelated to Parse
            occurred.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InternalServerError">

            Error code indicating that something has gone wrong with the server.
            If you get this error code, it is Parse's fault. Please report the bug to
            https://parse.com/help.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.ConnectionFailed">

            Error code indicating the connection to the Parse servers failed.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.ObjectNotFound">

            Error code indicating the specified object doesn't exist.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidQuery">

            Error code indicating you tried to query with a datatype that doesn't
            support it, like exact matching an array or object.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidClassName">

            Error code indicating a missing or invalid classname. Classnames are
            case-sensitive. They must start with a letter, and a-zA-Z0-9_ are the
            only valid characters.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.MissingObjectId">

            Error code indicating an unspecified object id.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidKeyName">

            Error code indicating an invalid key name. Keys are case-sensitive. They
            must start with a letter, and a-zA-Z0-9_ are the only valid characters.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidPointer">

            Error code indicating a malformed pointer. You should not see this unless
            you have been mucking about changing internal Parse code.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidJSON">

            Error code indicating that badly formed JSON was received upstream. This
            either indicates you have done something unusual with modifying how
            things encode to JSON, or the network is failing badly.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.CommandUnavailable">

            Error code indicating that the feature you tried to access is only
            available internally for testing purposes.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.NotInitialized">

            You must call Parse.initialize before using the Parse library.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.IncorrectType">

            Error code indicating that a field was set to an inconsistent type.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidChannelName">

            Error code indicating an invalid channel name. A channel name is either
            an empty string (the broadcast channel) or contains only a-zA-Z0-9_
            characters and starts with a letter.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.PushMisconfigured">

            Error code indicating that push is misconfigured.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.ObjectTooLarge">

            Error code indicating that the object is too large.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.OperationForbidden">

            Error code indicating that the operation isn't allowed for clients.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.CacheMiss">

            Error code indicating the result was not found in the cache.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidNestedKey">

            Error code indicating that an invalid key was used in a nested
            JSONObject.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidFileName">

            Error code indicating that an invalid filename was used for ParseFile.
            A valid file name contains only a-zA-Z0-9_. characters and is between 1
            and 128 characters.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidACL">

            Error code indicating an invalid ACL was provided.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.Timeout">

            Error code indicating that the request timed out on the server. Typically
            this indicates that the request is too expensive to run.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidEmailAddress">

            Error code indicating that the email address was invalid.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.DuplicateValue">

            Error code indicating that a unique field was given a value that is
            already taken.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidRoleName">

            Error code indicating that a role's name is invalid.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.ExceededQuota">

            Error code indicating that an application quota was exceeded. Upgrade to
            resolve.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.ScriptFailed">

            Error code indicating that a Cloud Code script failed.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.ValidationFailed">

            Error code indicating that a Cloud Code validation failed.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.FileDeleteFailed">

            Error code indicating that deleting a file failed.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.RequestLimitExceeded">

            Error code indicating that the application has exceeded its request limit.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidEventName">

            Error code indicating that the provided event name is invalid.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.UsernameMissing">

            Error code indicating that the username is missing or empty.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.PasswordMissing">

            Error code indicating that the password is missing or empty.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.UsernameTaken">

            Error code indicating that the username has already been taken.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.EmailTaken">

            Error code indicating that the email has already been taken.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.EmailMissing">

            Error code indicating that the email is missing, but must be specified.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.EmailNotFound">

            Error code indicating that a user with the specified email was not found.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.SessionMissing">

            Error code indicating that a user object without a valid session could
            not be altered.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.MustCreateUserThroughSignup">

            Error code indicating that a user can only be created through signup.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.AccountAlreadyLinked">

            Error code indicating that an an account being linked is already linked
            to another user.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidSessionToken">

            Error code indicating that the current session token is invalid.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.LinkedIdMissing">

            Error code indicating that a user cannot be linked to an account because
            that account's id could not be found.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.InvalidLinkedSession">

            Error code indicating that a user with a linked (e.g. Facebook) account
            has an invalid session.

        </member>
        <member name="F:Parse.ParseException.ErrorCode.UnsupportedService">

            Error code indicating that a service being linked (e.g. Facebook or
            Twitter) is unsupported.

        </member>
        <member name="P:Parse.ParseException.Code">

            The Parse error code associated with the exception.

        </member>
        <member name="T:Parse.ParseExtensions">

            Provides convenience extension methods for working with collections
            of ParseObjects so that you can easily save and fetch them in batches.

        </member>
        <member name="M:Parse.ParseExtensions.SaveAllAsync``1(System.Collections.Generic.IEnumerable{``0})">

            Saves all of the ParseObjects in the enumeration. Equivalent to
            calling <see cref="M:Parse.ParseObject.SaveAllAsync``1(System.Collections.Generic.IEnumerable{``0})"/>.

            <param name="objects">The objects to save.</param>
        </member>
        <member name="M:Parse.ParseExtensions.SaveAllAsync``1(System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken)">

            Saves all of the ParseObjects in the enumeration. Equivalent to
            calling
            <see cref="M:Parse.ParseObject.SaveAllAsync``1(System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken)"/>.

            <param name="objects">The objects to save.</param>
            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.ParseExtensions.FetchAllAsync``1(System.Collections.Generic.IEnumerable{``0})">

            Fetches all of the objects in the enumeration. Equivalent to
            calling <see cref="M:Parse.ParseObject.FetchAllAsync``1(System.Collections.Generic.IEnumerable{``0})"/>.

            <param name="objects">The objects to save.</param>
        </member>
        <member name="M:Parse.ParseExtensions.FetchAllAsync``1(System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken)">

            Fetches all of the objects in the enumeration. Equivalent to
            calling
            <see cref="M:Parse.ParseObject.FetchAllAsync``1(System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken)"/>.

            <param name="objects">The objects to fetch.</param>
            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.ParseExtensions.FetchAllIfNeededAsync``1(System.Collections.Generic.IEnumerable{``0})">

            Fetches all of the objects in the enumeration that don't already have
            data. Equivalent to calling
            <see cref="M:Parse.ParseObject.FetchAllIfNeededAsync``1(System.Collections.Generic.IEnumerable{``0})"/>.

            <param name="objects">The objects to fetch.</param>
        </member>
        <member name="M:Parse.ParseExtensions.FetchAllIfNeededAsync``1(System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken)">

            Fetches all of the objects in the enumeration that don't already have
            data. Equivalent to calling
            <see cref="M:Parse.ParseObject.FetchAllIfNeededAsync``1(System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken)"/>.

            <param name="objects">The objects to fetch.</param>
            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.ParseExtensions.Or``1(Parse.ParseQuery{``0},Parse.ParseQuery{``0}[])">

            Constructs a query that is the or of the given queries.

            <typeparam name="T">The type of ParseObject being queried.</typeparam>
            <param name="source">An initial query to 'or' with additional queries.</param>
            <param name="queries">The list of ParseQueries to 'or' together.</param>
            <returns>A query that is the or of the given queries.</returns>
        </member>
        <member name="M:Parse.ParseExtensions.FetchAsync``1(``0)">

            Fetches this object with the data from the server.

        </member>
        <member name="M:Parse.ParseExtensions.FetchAsync``1(``0,System.Threading.CancellationToken)">

            Fetches this object with the data from the server.

            <param name="obj">The ParseObject to fetch.</param>
            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.ParseExtensions.FetchIfNeededAsync``1(``0)">

            If this ParseObject has not been fetched (i.e. <see cref="P:Parse.ParseObject.IsDataAvailable"/> returns
            false), fetches this object with the data from the server.

            <param name="obj">The ParseObjhect to fetch.</param>
        </member>
        <member name="M:Parse.ParseExtensions.FetchIfNeededAsync``1(``0,System.Threading.CancellationToken)">

            If this ParseObject has not been fetched (i.e. <see cref="P:Parse.ParseObject.IsDataAvailable"/> returns
            false), fetches this object with the data from the server.

            <param name="obj">The ParseObject to fetch.</param>
            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="T:Parse.ParseGeoDistance">

            Represents a distance between two ParseGeoPoints.

        </member>
        <member name="M:Parse.ParseGeoDistance.#ctor(System.Double)">

            Creates a ParseGeoDistance.

            <param name="radians">The distance in radians.</param>
        </member>
        <member name="P:Parse.ParseGeoDistance.Radians">

            Gets the distance in radians.

        </member>
        <member name="P:Parse.ParseGeoDistance.Miles">

            Gets the distance in miles.

        </member>
        <member name="P:Parse.ParseGeoDistance.Kilometers">

            Gets the distance in kilometers.

        </member>
        <member name="M:Parse.ParseGeoDistance.FromMiles(System.Double)">

            Gets a ParseGeoDistance from a number of miles.

            <param name="miles">The number of miles.</param>
            <returns>A ParseGeoDistance for the given number of miles.</returns>
        </member>
        <member name="M:Parse.ParseGeoDistance.FromKilometers(System.Double)">

            Gets a ParseGeoDistance from a number of kilometers.

            <param name="kilometers">The number of kilometers.</param>
            <returns>A ParseGeoDistance for the given number of kilometers.</returns>
        </member>
        <member name="M:Parse.ParseGeoDistance.FromRadians(System.Double)">

            Gets a ParseGeoDistance from a number of radians.

            <param name="radians">The number of radians.</param>
            <returns>A ParseGeoDistance for the given number of radians.</returns>
        </member>
        <member name="T:Parse.ParseGeoPoint">

            ParseGeoPoint represents a latitude / longitude point that may be associated
            with a key in a ParseObject or used as a reference point for geo queries.
            This allows proximity-based queries on the key.

            Only one key in a class may contain a GeoPoint.

        </member>
        <member name="M:Parse.ParseGeoPoint.#ctor(System.Double,System.Double)">

            Constructs a ParseGeoPoint with the specified latitude and longitude.

            <param name="latitude">The point's latitude.</param>
            <param name="longitude">The point's longitude.</param>
        </member>
        <member name="P:Parse.ParseGeoPoint.Latitude">

            Gets or sets the latitude of the GeoPoint. Valid range is [-90, 90].
            Extremes should not be used.

        </member>
        <member name="P:Parse.ParseGeoPoint.Longitude">

            Gets or sets the longitude. Valid range is [-180, 180].
            Extremes should not be used.

        </member>
        <member name="M:Parse.ParseGeoPoint.DistanceTo(Parse.ParseGeoPoint)">

            Get the distance in radians between this point and another GeoPoint. This is the smallest angular
            distance between the two points.

            <param name="point">GeoPoint describing the other point being measured against.</param>
            <returns>The distance in between the two points.</returns>
        </member>
        <member name="T:Parse.ParseObject">

            The ParseObject is a local representation of data that can be saved and
            retrieved from the Parse cloud.
            <remarks>
            <para>
            The basic workflow for creating new data is to construct a new ParseObject,
            use the indexer to fill it with data, and then use SaveAsync() to persist to the
            database.
            </para>
            <para>
            The basic workflow for accessing existing data is to use a ParseQuery
            to specify which existing data to retrieve.
            </para>
            </remarks>
        </member>
        <member name="M:Parse.ParseObject.#ctor">

            Constructor for use in ParseObject subclasses. Subclasses must specify a ParseClassName attribute.

        </member>
        <member name="M:Parse.ParseObject.#ctor(System.String)">

            Constructs a new ParseObject with no data in it. A ParseObject constructed in this way will
            not have an ObjectId and will not persist to the database until <see cref="M:Parse.ParseObject.SaveAsync"/>
            is called.

            <remarks>
            Class names must be alphanumerical plus underscore, and start with a letter. It is recommended
            to name classes in CamelCaseLikeThis.
            </remarks>
            <param name="className">The className for this ParseObject.</param>
        </member>
        <member name="M:Parse.ParseObject.Create(System.String)">

            Creates a new ParseObject based upon a class name. If the class name is a special type (e.g.
            for <see cref="T:Parse.ParseUser"/>), then the appropriate type of ParseObject is returned.

            <param name="className">The class of object to create.</param>
            <returns>A new ParseObject for the given class name.</returns>
        </member>
        <member name="M:Parse.ParseObject.CreateWithoutData(System.String,System.String)">

            Creates a reference to an existing ParseObject for use in creating associations between
            ParseObjects. Calling <see cref="P:Parse.ParseObject.IsDataAvailable"/> on this object will return
            <c>false</c> until <see cref="M:Parse.ParseExtensions.FetchIfNeededAsync``1(``0)"/> has been called.
            No network request will be made.

            <param name="className">The object's class.</param>
            <param name="objectId">The object id for the referenced object.</param>
            <returns>A ParseObject without data.</returns>
        </member>
        <member name="M:Parse.ParseObject.Create``1">

            Creates a new ParseObject based upon a given subclass type.

            <returns>A new ParseObject for the given class name.</returns>
        </member>
        <member name="M:Parse.ParseObject.CreateWithoutData``1(System.String)">

            Creates a reference to an existing ParseObject for use in creating associations between
            ParseObjects. Calling <see cref="P:Parse.ParseObject.IsDataAvailable"/> on this object will return
            <c>false</c> until <see cref="M:Parse.ParseExtensions.FetchIfNeededAsync``1(``0)"/> has been called.
            No network request will be made.

            <param name="objectId">The object id for the referenced object.</param>
            <returns>A ParseObject without data.</returns>
        </member>
        <member name="M:Parse.ParseObject.SetProperty``1(``0,System.String)">

            Sets the value of a property based upon its associated ParseFieldName attribute.

            <param name="value">The new value.</param>
            <param name="propertyName">The name of the property.</param>
            <typeparam name="T">The type for the property.</typeparam>
        </member>
        <member name="M:Parse.ParseObject.GetRelationProperty``1(System.String)">

            Gets a relation for a property based upon its associated ParseFieldName attribute.

            <returns>The ParseRelation for the property.</returns>
            <param name="propertyName">The name of the property.</param>
            <typeparam name="T">The ParseObject subclass type of the ParseRelation.</typeparam>
        </member>
        <member name="M:Parse.ParseObject.GetProperty``1(System.String)">

            Gets the value of a property based upon its associated ParseFieldName attribute.

            <returns>The value of the property.</returns>
            <param name="propertyName">The name of the property.</param>
            <typeparam name="T">The return type of the property.</typeparam>
        </member>
        <member name="M:Parse.ParseObject.GetProperty``1(``0,System.String)">

            Gets the value of a property based upon its associated ParseFieldName attribute.

            <returns>The value of the property.</returns>
            <param name="defaultValue">The value to return if the property is not present on the ParseObject.</param>
            <param name="propertyName">The name of the property.</param>
            <typeparam name="T">The return type of the property.</typeparam>
        </member>
        <member name="M:Parse.ParseObject.SetDefaultValues">

            Allows subclasses to set values for non-pointer construction.

        </member>
        <member name="M:Parse.ParseObject.RegisterSubclass``1">

            Registers a custom subclass type with the Parse SDK, enabling strong-typing of those ParseObjects whenever
            they appear. Subclasses must specify the ParseClassName attribute, have a default constructor, and properties
            backed by ParseObject fields should have ParseFieldName attributes supplied.

            <typeparam name="T">The ParseObject subclass type to register.</typeparam>
        </member>
        <member name="M:Parse.ParseObject.Revert">

            Clears any changes to this object made since the last call to <see cref="M:Parse.ParseObject.SaveAsync"/>.

        </member>
        <member name="M:Parse.ParseObject.DeepTraversal(System.Object,System.Boolean,System.Boolean)">

            Flattens dictionaries and lists into a single enumerable of all contained objects
            that can then be queried over.

            <param name="root">The root of the traversal</param>
            <param name="traverseParseObjects">Whether to traverse into ParseObjects' children</param>
            <param name="yieldRoot">Whether to include the root in the result</param>
            <returns></returns>
        </member>
        <member name="M:Parse.ParseObject.CollectFetchedObjects">

            Deep traversal of this object to grab a copy of any object referenced by this object.
            These instances may have already been fetched, and we don't want to lose their data when
            refreshing or saving.

            <returns>Map of objectId to ParseObject which have been fetched.</returns>
        </member>
        <member name="M:Parse.ParseObject.StartSave">

            Pushes new operations onto the queue and returns the current set of operations.

        </member>
        <member name="M:Parse.ParseObject.SaveAsync">

            Saves this object to the server.

        </member>
        <member name="M:Parse.ParseObject.SaveAsync(System.Threading.CancellationToken)">

            Saves this object to the server.

            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.ParseObject.SaveAllAsync``1(System.Collections.Generic.IEnumerable{``0})">

            Saves each object in the provided list.

            <param name="objects">The objects to save.</param>
        </member>
        <member name="M:Parse.ParseObject.SaveAllAsync``1(System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken)">

            Saves each object in the provided list.

            <param name="objects">The objects to save.</param>
            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.ParseObject.FetchAsyncInternal(System.Threading.CancellationToken)">

            Fetches this object with the data from the server.

            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.ParseObject.FetchIfNeededAsyncInternal(System.Threading.CancellationToken)">

            If this ParseObject has not been fetched (i.e. <see cref="P:Parse.ParseObject.IsDataAvailable"/> returns
            false), fetches this object with the data from the server.

            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.ParseObject.FetchAllIfNeededAsync``1(System.Collections.Generic.IEnumerable{``0})">

            Fetches all of the objects that don't have data in the provided list.

            <returns>The list passed in for convenience.</returns>
        </member>
        <member name="M:Parse.ParseObject.FetchAllIfNeededAsync``1(System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken)">

            Fetches all of the objects that don't have data in the provided list.

            <param name="objects">The objects to fetch.</param>
            <param name="cancellationToken">The cancellation token.</param>
            <returns>The list passed in for convenience.</returns>
        </member>
        <member name="M:Parse.ParseObject.FetchAllAsync``1(System.Collections.Generic.IEnumerable{``0})">

            Fetches all of the objects in the provided list.

            <param name="objects">The objects to fetch.</param>
            <returns>The list passed in for convenience.</returns>
        </member>
        <member name="M:Parse.ParseObject.FetchAllAsync``1(System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken)">

            Fetches all of the objects in the provided list.

            <param name="objects">The objects to fetch.</param>
            <param name="cancellationToken">The cancellation token.</param>
            <returns>The list passed in for convenience.</returns>
        </member>
        <member name="M:Parse.ParseObject.FetchAllInternalAsync``1(System.Collections.Generic.IEnumerable{``0},System.Boolean,System.Threading.Tasks.Task,System.Threading.CancellationToken)">

            Fetches all of the objects in the list.

            <param name="objects">The objects to fetch.</param>
            <param name="force">If false, only objects without data will be fetched.</param>
            <param name="toAwait">A task to await before starting.</param>
            <param name="cancellationToken">The cancellation token.</param>
            <returns>The list passed in for convenience.</returns>
        </member>
        <member name="M:Parse.ParseObject.DeleteAsync">

            Deletes this object on the server.

        </member>
        <member name="M:Parse.ParseObject.DeleteAsync(System.Threading.CancellationToken)">

            Deletes this object on the server.

            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.ParseObject.DeleteAllAsync``1(System.Collections.Generic.IEnumerable{``0})">

            Deletes each object in the provided list.

            <param name="objects">The objects to delete.</param>
        </member>
        <member name="M:Parse.ParseObject.DeleteAllAsync``1(System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken)">

            Deletes each object in the provided list.

            <param name="objects">The objects to delete.</param>
            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.ParseObject.CollectDirtyChildren(System.Object,System.Collections.Generic.IList{Parse.ParseObject})">

            Helper version of CollectDirtyChildren so that callers don't have to add the internally
            used parameters.

        </member>
        <member name="M:Parse.ParseObject.CanBeSerializedAsValue(System.Object)">

            Returns true if the given object can be serialized for saving as a value
            that is pointed to by a ParseObject.

        </member>
        <member name="M:Parse.ParseObject.EnqueueForAll``1(System.Collections.Generic.IEnumerable{Parse.ParseObject},System.Func{System.Threading.Tasks.Task,System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken)">

            Adds a task to the queue for all of the given objects.

        </member>
        <member name="M:Parse.ParseObject.Remove(System.String)">

            Removes a key from the object's data if it exists.

            <param name="key">The key to remove.</param>
        </member>
        <member name="M:Parse.ParseObject.RebuildEstimatedData">

            Regenerates the estimatedData map from the serverData and operations.

        </member>
        <member name="M:Parse.ParseObject.PerformOperation(System.String,Parse.Internal.IParseFieldOperation)">

            PerformOperation is like setting a value at an index, but instead of
            just taking a new value, it takes a ParseFieldOperation that modifies the value.

        </member>
        <member name="M:Parse.ParseObject.OnSettingValue(System.String@,System.Object@)">

            Override to run validations on key/value pairs. Make sure to still
            call the base version.

        </member>
        <member name="P:Parse.ParseObject.Item(System.String)">

            Gets or sets a value on the object. It is recommended to name
            keys in partialCamelCaseLikeThis.

            <param name="key">The key for the object. Keys must be alphanumeric plus underscore
            and start with a letter.</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="M:Parse.ParseObject.Set(System.String,System.Object)">

            Perform Set internally which is not gated by mutability check.

            <param name="key">key for the object.</param>
            <param name="value">the value for the key.</param>
        </member>
        <member name="M:Parse.ParseObject.Increment(System.String)">

            Atomically increments the given key by 1.

            <param name="key">The key to increment.</param>
        </member>
        <member name="M:Parse.ParseObject.Increment(System.String,System.Int64)">

            Atomically increments the given key by the given number.

            <param name="key">The key to increment.</param>
            <param name="amount">The amount to increment by.</param>
        </member>
        <member name="M:Parse.ParseObject.Increment(System.String,System.Double)">

            Atomically increments the given key by the given number.

            <param name="key">The key to increment.</param>
            <param name="amount">The amount to increment by.</param>
        </member>
        <member name="M:Parse.ParseObject.AddToList(System.String,System.Object)">

            Atomically adds an object to the end of the list associated with the given key.

            <param name="key">The key.</param>
            <param name="value">The object to add.</param>
        </member>
        <member name="M:Parse.ParseObject.AddRangeToList``1(System.String,System.Collections.Generic.IEnumerable{``0})">

            Atomically adds objects to the end of the list associated with the given key.

            <param name="key">The key.</param>
            <param name="values">The objects to add.</param>
        </member>
        <member name="M:Parse.ParseObject.AddUniqueToList(System.String,System.Object)">

            Atomically adds an object to the end of the list associated with the given key,
            only if it is not already present in the list. The position of the insert is not
            guaranteed.

            <param name="key">The key.</param>
            <param name="value">The object to add.</param>
        </member>
        <member name="M:Parse.ParseObject.AddRangeUniqueToList``1(System.String,System.Collections.Generic.IEnumerable{``0})">

            Atomically adds objects to the end of the list associated with the given key,
            only if they are not already present in the list. The position of the inserts are not
            guaranteed.

            <param name="key">The key.</param>
            <param name="values">The objects to add.</param>
        </member>
        <member name="M:Parse.ParseObject.RemoveAllFromList``1(System.String,System.Collections.Generic.IEnumerable{``0})">

            Atomically removes all instances of the objects in <paramref name="values"/>
            from the list associated with the given key.

            <param name="key">The key.</param>
            <param name="values">The objects to remove.</param>
        </member>
        <member name="M:Parse.ParseObject.ContainsKey(System.String)">

            Returns whether this object has a particular key.

            <param name="key">The key to check for</param>
        </member>
        <member name="M:Parse.ParseObject.Get``1(System.String)">

            Gets a value for the key of a particular type.
            <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<T>, IDictionary<string, T>, 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>

        </member>
        <member name="M:Parse.ParseObject.GetRelation``1(System.String)">

            Access or create a Relation value for a key.

            <typeparam name="T">The type of object to create a relation for.</typeparam>
            <param name="key">The key for the relation field.</param>
            <returns>A ParseRelation for the key.</returns>
        </member>
        <member name="M:Parse.ParseObject.TryGetValue``1(System.String,``0@)">

            Populates result with the value for the key, if possible.

            <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.ParseObject.IsDataAvailable">

            Gets whether the ParseObject has been fetched.

        </member>
        <member name="M:Parse.ParseObject.HasSameId(Parse.ParseObject)">

            A helper function for checking whether two ParseObjects point to
            the same object in the cloud.

        </member>
        <member name="P:Parse.ParseObject.Keys">

            Gets a set view of the keys contained in this object. This does not include createdAt,
            updatedAt, or objectId. It does include things like username and ACL.

        </member>
        <member name="P:Parse.ParseObject.ACL">

            Gets or sets the ParseACL governing this object.

        </member>
        <member name="P:Parse.ParseObject.IsNew">

            Returns true if this object was created by the Parse server when the
            object might have already been there (e.g. in the case of a Facebook
            login)

        </member>
        <member name="P:Parse.ParseObject.UpdatedAt">

            Gets the last time this object was updated as the server sees it, so that if you make changes
            to a ParseObject, then wait a while, and then call <see cref="M:Parse.ParseObject.SaveAsync"/>, the updated time
            will be the time of the <see cref="M:Parse.ParseObject.SaveAsync"/> call rather than the time the object was
            changed locally.

        </member>
        <member name="P:Parse.ParseObject.CreatedAt">

            Gets the first time this object was saved as the server sees it, so that if you create a
            ParseObject, then wait a while, and then call <see cref="M:Parse.ParseObject.SaveAsync"/>, the
            creation time will be the time of the first <see cref="M:Parse.ParseObject.SaveAsync"/> call rather than
            the time the object was created locally.

        </member>
        <member name="P:Parse.ParseObject.IsDirty">

            Indicates whether this ParseObject has unsaved changes.

        </member>
        <member name="M:Parse.ParseObject.IsKeyDirty(System.String)">

            Indicates whether key is unsaved for this ParseObject.

            <param name="key">The key to check for.</param>
            <returns><c>true</c> if the key has been altered and not saved yet, otherwise
            <c>false</c>.</returns>
        </member>
        <member name="P:Parse.ParseObject.ObjectId">

            Gets or sets the object id. An object id is assigned as soon as an object is
            saved to the server. The combination of a <see cref="P:Parse.ParseObject.ClassName"/> and an
            <see cref="P:Parse.ParseObject.ObjectId"/> uniquely identifies an object in your application.

        </member>
        <member name="M:Parse.ParseObject.SetObjectIdInternal(System.String)">

            Sets the objectId without marking dirty.

            <param name="objectId">The new objectId</param>
        </member>
        <member name="P:Parse.ParseObject.ClassName">

            Gets the class name for the ParseObject.

        </member>
        <member name="M:Parse.ParseObject.Add(System.String,System.Object)">

            Adds a value for the given key, throwing an Exception if the key
            already has a value.

            <remarks>
            This allows you to use collection initialization syntax when creating ParseObjects,
            such as:

            var obj = new ParseObject("MyType")
            {
                {"name", "foo"},
                {"count", 10},
                {"found", false}
            };

            </remarks>
            <param name="key">The key for which a value should be set.</param>
            <param name="value">The value for the key.</param>
        </member>
        <member name="M:Parse.ParseObject.GetQuery(System.String)">

            Gets a <see cref="T:Parse.ParseQuery`1"/> for the type of object specified by
            <paramref name="className"/>

            <param name="className">The class name of the object.</param>
            <returns>A new <see cref="T:Parse.ParseQuery`1"/>.</returns>
        </member>
        <member name="M:Parse.ParseObject.OnFieldsChanged(System.Collections.Generic.IEnumerable{System.String})">

            Raises change notifications for all properties associated with the given
            field names. If fieldNames is null, this will notify for all known field-linked
            properties (e.g. this happens when we recalculate all estimated data from scratch)

        </member>
        <member name="M:Parse.ParseObject.OnPropertyChanged(System.String)">

            Raises change notifications for a property. Passing null or the empty string
            notifies the binding framework that all properties/indexes have changed.
            Passing "Item[]" tells the binding framework that all indexed values
            have changed (but not all properties)

        </member>
        <member name="E:Parse.ParseObject.PropertyChanged">

            Occurs when a property value changes.

        </member>
        <member name="T:Parse.ParseQuery`1">

             The ParseQuery class defines a query that is used to fetch ParseObjects. The
             most common use case is finding all objects that match a query through the
             <see cref="M:Parse.ParseQuery`1.FindAsync"/> method.

             <example>
             This sample code fetches all objects of
             class <c>"MyClass"</c>:

             ParseQuery query = new ParseQuery("MyClass");
             IEnumerable<ParseObject> result = await query.FindAsync();

             A ParseQuery can also be used to retrieve a single object whose id is known,
             through the <see cref="M:Parse.ParseQuery`1.GetAsync(System.String)"/> method. For example, this sample code
             fetches an object of class <c>"MyClass"</c> and id <c>myId</c>.

             ParseQuery query = new ParseQuery("MyClass");
             ParseObject result = await query.GetAsync(myId);

             A ParseQuery can also be used to count the number of objects that match the
             query without retrieving all of those objects. For example, this sample code
             counts the number of objects of the class <c>"MyClass"</c>.

             ParseQuery query = new ParseQuery("MyClass");
             int count = await query.CountAsync();

             </example>
        </member>
        <member name="M:Parse.ParseQuery`1.#ctor(Parse.ParseQuery{`0},System.Collections.Generic.IDictionary{System.String,System.Object},System.Collections.Generic.IEnumerable{System.String},System.Collections.Generic.IEnumerable{System.String},System.Nullable{System.Int32},System.Nullable{System.Int32},System.Collections.Generic.IEnumerable{System.String},System.Collections.Generic.IEnumerable{System.String},System.String)">

            Private constructor for composition of queries. A source query is required,
            but the remaining values can be null if they won't be changed in this
            composition.

        </member>
        <member name="M:Parse.ParseQuery`1.#ctor">

            Constructs a query based upon the ParseObject subclass used as the generic parameter for the ParseQuery.

        </member>
        <member name="M:Parse.ParseQuery`1.#ctor(System.String)">

            Constructs a query. A default query with no further parameters will retrieve
            all <see cref="T:Parse.ParseObject"/>s of the provided class.

            <param name="className">The name of the class to retrieve ParseObjects for.</param>
        </member>
        <member name="M:Parse.ParseQuery`1.Or(System.Collections.Generic.IEnumerable{Parse.ParseQuery{`0}})">

            Constructs a query that is the or of the given queries.

            <param name="queries">The list of ParseQueries to 'or' together.</param>
            <returns>A ParseQquery that is the 'or' of the passed in queries.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.OrderBy(System.String)">

            Sorts the results in ascending order by the given key.
            This will override any existing ordering for the query.

            <param name="key">The key to order by.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.OrderByDescending(System.String)">

            Sorts the results in descending order by the given key.
            This will override any existing ordering for the query.

            <param name="key">The key to order by.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.ThenBy(System.String)">

             Sorts the results in ascending order by the given key, after previous
             ordering has been applied.

             This method can only be called if there is already an <see cref="M:Parse.ParseQuery`1.OrderBy(System.String)"/>
             or <see cref="M:Parse.ParseQuery`1.OrderByDescending(System.String)"/>
             on this query.

             <param name="key">The key to order by.</param>
             <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.ThenByDescending(System.String)">

             Sorts the results in descending order by the given key, after previous
             ordering has been applied.

             This method can only be called if there is already an <see cref="M:Parse.ParseQuery`1.OrderBy(System.String)"/>
             or <see cref="M:Parse.ParseQuery`1.OrderByDescending(System.String)"/> on this query.

             <param name="key">The key to order by.</param>
             <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.Include(System.String)">

            Include nested ParseObjects for the provided key. You can use dot notation
            to specify which fields in the included objects should also be fetched.

            <param name="key">The key that should be included.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.Select(System.String)">

            Restrict the fields of returned ParseObjects to only include the provided key.
            If this is called multiple times, then all of the keys specified in each of
            the calls will be included.

            <param name="key">The key that should be included.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.Skip(System.Int32)">

            Skips a number of results before returning. This is useful for pagination
            of large queries. Chaining multiple skips together will cause more results
            to be skipped.

            <param name="count">The number of results to skip.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.Limit(System.Int32)">

            Controls the maximum number of results that are returned. Setting a negative
            limit denotes retrieval without a limit. Chaining multiple limits
            results in the last limit specified being used. The default limit is
            100, with a maximum of 1000 results being returned at a time.

            <param name="count">The maximum number of results to return.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereContainedIn``1(System.String,System.Collections.Generic.IEnumerable{``0})">

            Adds a constraint to the query that requires a particular key's value to be
            contained in the provided list of values.

            <param name="key">The key to check.</param>
            <param name="values">The values that will match.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereContainsAll``1(System.String,System.Collections.Generic.IEnumerable{``0})">

            Add a constraint to the querey that requires a particular key's value to be
            a list containing all of the elements in the provided list of values.

            <param name="key">The key to check.</param>
            <param name="values">The values that will match.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereContains(System.String,System.String)">

            Adds a constraint for finding string values that contain a provided string.
            This will be slow for large data sets.

            <param name="key">The key that the string to match is stored in.</param>
            <param name="substring">The substring that the value must contain.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereDoesNotExist(System.String)">

            Adds a constraint for finding objects that do not contain a given key.

            <param name="key">The key that should not exist.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereDoesNotMatchQuery``1(System.String,Parse.ParseQuery{``0})">

            Adds a constraint to the query that requires that a particular key's value
            does not match another ParseQuery. This only works on keys whose values are
            ParseObjects or lists of ParseObjects.

            <param name="key">The key to check.</param>
            <param name="query">The query that the value should not match.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereEndsWith(System.String,System.String)">

            Adds a constraint for finding string values that end with a provided string.
            This will be slow for large data sets.

            <param name="key">The key that the string to match is stored in.</param>
            <param name="suffix">The substring that the value must end with.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereEqualTo(System.String,System.Object)">

            Adds a constraint to the query that requires a particular key's value to be
            equal to the provided value.

            <param name="key">The key to check.</param>
            <param name="value">The value that the ParseObject must contain.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereExists(System.String)">

            Adds a constraint for finding objects that contain a given key.

            <param name="key">The key that should exist.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereGreaterThan(System.String,System.Object)">

            Adds a constraint to the query that requires a particular key's value to be
            greater than the provided value.

            <param name="key">The key to check.</param>
            <param name="value">The value that provides a lower bound.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereGreaterThanOrEqualTo(System.String,System.Object)">

            Adds a constraint to the query that requires a particular key's value to be
            greater or equal to than the provided value.

            <param name="key">The key to check.</param>
            <param name="value">The value that provides a lower bound.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereLessThan(System.String,System.Object)">

            Adds a constraint to the query that requires a particular key's value to be
            less than the provided value.

            <param name="key">The key to check.</param>
            <param name="value">The value that provides an upper bound.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereLessThanOrEqualTo(System.String,System.Object)">

            Adds a constraint to the query that requires a particular key's value to be
            less than or equal to the provided value.

            <param name="key">The key to check.</param>
            <param name="value">The value that provides a lower bound.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereMatches(System.String,System.Text.RegularExpressions.Regex,System.String)">

            Adds a regular expression constraint for finding string values that match the provided
            regular expression. This may be slow for large data sets.

            <param name="key">The key that the string to match is stored in.</param>
            <param name="regex">The regular expression pattern to match. The Regex must
            have the <see cref="F:System.Text.RegularExpressions.RegexOptions.ECMAScript"/> options flag set.</param>
            <param name="modifiers">Any of the following supported PCRE modifiers:
            i - Case insensitive search
            m Search across multiple lines of input</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereMatches(System.String,System.Text.RegularExpressions.Regex)">

            Adds a regular expression constraint for finding string values that match the provided
            regular expression. This may be slow for large data sets.

            <param name="key">The key that the string to match is stored in.</param>
            <param name="regex">The regular expression pattern to match. The Regex must
            have the <see cref="F:System.Text.RegularExpressions.RegexOptions.ECMAScript"/> options flag set.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereMatches(System.String,System.String,System.String)">

            Adds a regular expression constraint for finding string values that match the provided
            regular expression. This may be slow for large data sets.

            <param name="key">The key that the string to match is stored in.</param>
            <param name="pattern">The PCRE regular expression pattern to match.</param>
            <param name="modifiers">Any of the following supported PCRE modifiers:
            i - Case insensitive search
            m Search across multiple lines of input</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereMatches(System.String,System.String)">

            Adds a regular expression constraint for finding string values that match the provided
            regular expression. This may be slow for large data sets.

            <param name="key">The key that the string to match is stored in.</param>
            <param name="pattern">The PCRE regular expression pattern to match.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereMatchesKeyInQuery``1(System.String,System.String,Parse.ParseQuery{``0})">

            Adds a constraint to the query that requires a particular key's value
            to match a value for a key in the results of another ParseQuery.

            <param name="key">The key whose value is being checked.</param>
            <param name="keyInQuery">The key in the objects from the subquery to look in.</param>
            <param name="query">The subquery to run</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereDoesNotMatchesKeyInQuery``1(System.String,System.String,Parse.ParseQuery{``0})">

            Adds a constraint to the query that requires a particular key's value
            does not match any value for a key in the results of another ParseQuery.

            <param name="key">The key whose value is being checked.</param>
            <param name="keyInQuery">The key in the objects from the subquery to look in.</param>
            <param name="query">The subquery to run</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereMatchesQuery``1(System.String,Parse.ParseQuery{``0})">

            Adds a constraint to the query that requires that a particular key's value
            matches another ParseQuery. This only works on keys whose values are
            ParseObjects or lists of ParseObjects.

            <param name="key">The key to check.</param>
            <param name="query">The query that the value should match.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereNear(System.String,Parse.ParseGeoPoint)">

            Adds a proximity-based constraint for finding objects with keys whose GeoPoint
            values are near the given point.

            <param name="key">The key that the ParseGeoPoint is stored in.</param>
            <param name="point">The reference ParseGeoPoint.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereNotContainedIn``1(System.String,System.Collections.Generic.IEnumerable{``0})">

            Adds a constraint to the query that requires a particular key's value to be
            contained in the provided list of values.

            <param name="key">The key to check.</param>
            <param name="values">The values that will match.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereNotEqualTo(System.String,System.Object)">

            Adds a constraint to the query that requires a particular key's value not
            to be equal to the provided value.

            <param name="key">The key to check.</param>
            <param name="value">The value that that must not be equalled.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereStartsWith(System.String,System.String)">

            Adds a constraint for finding string values that start with the provided string.
            This query will use the backend index, so it will be fast even with large data sets.

            <param name="key">The key that the string to match is stored in.</param>
            <param name="suffix">The substring that the value must start with.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereWithinGeoBox(System.String,Parse.ParseGeoPoint,Parse.ParseGeoPoint)">

            Add a constraint to the query that requires a particular key's coordinates to be
            contained within a given rectangular geographic bounding box.

            <param name="key">The key to be constrained.</param>
            <param name="southwest">The lower-left inclusive corner of the box.</param>
            <param name="northeast">The upper-right inclusive corner of the box.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.WhereWithinDistance(System.String,Parse.ParseGeoPoint,Parse.ParseGeoDistance)">

            Adds a proximity-based constraint for finding objects with keys whose GeoPoint
            values are near the given point and within the maximum distance given.

            <param name="key">The key that the ParseGeoPoint is stored in.</param>
            <param name="point">The reference ParseGeoPoint.</param>
            <param name="maxDistance">The maximum distance (in radians) of results to return.</param>
            <returns>A new query with the additional constraint.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.FindAsync">

            Retrieves a list of ParseObjects that satisfy this query from Parse.

            <returns>The list of ParseObjects that match this query.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.FindAsync(System.Threading.CancellationToken)">

            Retrieves a list of ParseObjects that satisfy this query from Parse.

            <param name="cancellationToken">The cancellation token.</param>
            <returns>The list of ParseObjects that match this query.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.FirstOrDefaultAsync">

            Retrieves at most one ParseObject that satisfies this query.

            <returns>A single ParseObject that satisfies this query, or else null.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.FirstOrDefaultAsync(System.Threading.CancellationToken)">

            Retrieves at most one ParseObject that satisfies this query.

            <param name="cancellationToken">The cancellation token.</param>
            <returns>A single ParseObject that satisfies this query, or else null.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.FirstAsync">

            Retrieves at most one ParseObject that satisfies this query.

            <returns>A single ParseObject that satisfies this query.</returns>
            <exception cref="T:Parse.ParseException">If no results match the query.</exception>
        </member>
        <member name="M:Parse.ParseQuery`1.FirstAsync(System.Threading.CancellationToken)">

            Retrieves at most one ParseObject that satisfies this query.

            <param name="cancellationToken">The cancellation token.</param>
            <returns>A single ParseObject that satisfies this query.</returns>
            <exception cref="T:Parse.ParseException">If no results match the query.</exception>
        </member>
        <member name="M:Parse.ParseQuery`1.CountAsync">

            Counts the number of objects that match this query.

            <returns>The number of objects that match this query.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.CountAsync(System.Threading.CancellationToken)">

            Counts the number of objects that match this query.

            <param name="cancellationToken">The cancellation token.</param>
            <returns>The number of objects that match this query.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.GetAsync(System.String)">

            Constructs a ParseObject whose id is already known by fetching data
            from the server.

            <param name="objectId">ObjectId of the ParseObject to fetch.</param>
            <returns>The ParseObject for the given objectId.</returns>
        </member>
        <member name="M:Parse.ParseQuery`1.GetAsync(System.String,System.Threading.CancellationToken)">

            Constructs a ParseObject whose id is already known by fetching data
            from the server.

            <param name="objectId">ObjectId of the ParseObject to fetch.</param>
            <param name="cancellationToken">The cancellation token.</param>
            <returns>The ParseObject for the given objectId.</returns>
        </member>
        <member name="T:Parse.ParseRelationBase">

            A common base class for ParseRelations.

        </member>
        <member name="M:Parse.ParseRelationBase.CreateRelation(Parse.ParseObject,System.String,System.String)">

            Produces the proper ParseRelation<T> instance for the given classname.

        </member>
        <member name="T:Parse.ParseRelation`1">

            Provides access to all of the children of a many-to-many relationship. Each instance of
            ParseRelation is associated with a particular parent and key.

            <typeparam name="T">The type of the child objects.</typeparam>
        </member>
        <member name="M:Parse.ParseRelation`1.Add(`0)">

            Adds an object to this relation. The object must already have been saved.

            <param name="obj">The object to add.</param>
        </member>
        <member name="M:Parse.ParseRelation`1.Remove(`0)">

            Removes an object from this relation. The object must already have been saved.

            <param name="obj">The object to remove.</param>
        </member>
        <member name="P:Parse.ParseRelation`1.Query">

            Gets a query that can be used to query the objects in this relation.

        </member>
        <member name="T:Parse.ParseRole">

            Represents a Role on the Parse server. ParseRoles represent groupings
            of <see cref="T:Parse.ParseUser"/>s for the purposes of granting permissions (e.g.
            specifying a <see cref="T:Parse.ParseACL"/> for a <see cref="T:Parse.ParseObject"/>. Roles
            are specified by their sets of child users and child roles, all of which are granted
            any permissions that the parent role has.

            Roles must have a name (that cannot be changed after creation of the role),
            and must specify an ACL.

        </member>
        <member name="M:Parse.ParseRole.#ctor">

            Constructs a new ParseRole. You must assign a name and ACL to the role.

        </member>
        <member name="M:Parse.ParseRole.#ctor(System.String,Parse.ParseACL)">

            Constructs a new ParseRole with the given name.

            <param name="name">The name of the role to create.</param>
            <param name="acl">The ACL for this role. Roles must have an ACL.</param>
        </member>
        <member name="P:Parse.ParseRole.Name">

            Gets the name of the role.

        </member>
        <member name="P:Parse.ParseRole.Users">

            Gets the <see cref="T:Parse.ParseRelation`1"/> for the <see cref="T:Parse.ParseUser"/>s that are
            direct children of this role. These users are granted any privileges that
            this role has been granted (e.g. read or write access through ACLs). You can
            add or remove child users from the role through this relation.

        </member>
        <member name="P:Parse.ParseRole.Roles">

            Gets the <see cref="T:Parse.ParseRelation`1"/> for the <see cref="T:Parse.ParseRole"/>s that are
            direct children of this role. These roles' users are granted any privileges that
            this role has been granted (e.g. read or write access through ACLs). You can
            add or remove child roles from the role through this relation.

        </member>
        <member name="P:Parse.ParseRole.Query">

            Gets a <see cref="T:Parse.ParseQuery`1"/> over the Role collection.

        </member>
        <member name="T:Parse.ParseSession">

            Represents a session of a user for a Parse application.

        </member>
        <member name="P:Parse.ParseSession.SessionToken">

            Gets the session token for a user, if they are logged in.

        </member>
        <member name="P:Parse.ParseSession.Query">

            Constructs a <see cref="T:Parse.ParseQuery`1"/> for ParseSession.

        </member>
        <member name="M:Parse.ParseSession.GetCurrentSessionAsync">

            Gets the current <see cref="T:Parse.ParseSession"/> object related to the current user.

        </member>
        <member name="M:Parse.ParseSession.GetCurrentSessionAsync(System.Threading.CancellationToken)">

            Gets the current <see cref="T:Parse.ParseSession"/> object related to the current user.

            <param name="cancellationToken">The cancellation token</param>
        </member>
        <member name="T:Parse.ParseUploadProgressEventArgs">

            Represents upload progress.

        </member>
        <member name="P:Parse.ParseUploadProgressEventArgs.Progress">

            Gets the progress (a number between 0.0 and 1.0) of an upload.

        </member>
        <member name="T:Parse.ParseUser">

            Represents a user for a Parse application.

        </member>
        <member name="P:Parse.ParseUser.IsAuthenticated">

            Whether the ParseUser has been authenticated on this device. Only an authenticated
            ParseUser can be saved and deleted.

        </member>
        <member name="M:Parse.ParseUser.Remove(System.String)">

            Removes a key from the object's data if it exists.

            <param name="key">The key to remove.</param>
            <exception cref="T:System.ArgumentException">Cannot remove the username key.</exception>
        </member>
        <member name="P:Parse.ParseUser.Username">

            Gets or sets the username.

        </member>
        <member name="P:Parse.ParseUser.Password">

            Sets the password.

        </member>
        <member name="P:Parse.ParseUser.Email">

            Sets the email address.

        </member>
        <member name="M:Parse.ParseUser.SignUpAsync">

            Signs up a new user. This will create a new ParseUser on the server and will also persist the
            session on disk so that you can access the user using <see cref="P:Parse.ParseUser.CurrentUser"/>. A username and
            password must be set before calling SignUpAsync.

        </member>
        <member name="M:Parse.ParseUser.SignUpAsync(System.Threading.CancellationToken)">

            Signs up a new user. This will create a new ParseUser on the server and will also persist the
            session on disk so that you can access the user using <see cref="P:Parse.ParseUser.CurrentUser"/>. A username and
            password must be set before calling SignUpAsync.

            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="M:Parse.ParseUser.LogInAsync(System.String,System.String)">

            Logs in a user with a username and password. On success, this saves the session to disk so you
            can retrieve the currently logged in user using <see cref="P:Parse.ParseUser.CurrentUser"/>.

            <param name="username">The username to log in with.</param>
            <param name="password">The password to log in with.</param>
            <returns>The newly logged-in user.</returns>
        </member>
        <member name="M:Parse.ParseUser.LogInAsync(System.String,System.String,System.Threading.CancellationToken)">

            Logs in a user with a username and password. On success, this saves the session to disk so you
            can retrieve the currently logged in user using <see cref="P:Parse.ParseUser.CurrentUser"/>.

            <param name="username">The username to log in with.</param>
            <param name="password">The password to log in with.</param>
            <param name="cancellationToken">The cancellation token.</param>
            <returns>The newly logged-in user.</returns>
        </member>
        <member name="M:Parse.ParseUser.BecomeAsync(System.String)">

            Logs in a user with a username and password. On success, this saves the session to disk so you
            can retrieve the currently logged in user using <see cref="P:Parse.ParseUser.CurrentUser"/>.

            <param name="sessionToken">The session token to authorize with</param>
            <returns>The user if authorization was successful</returns>
        </member>
        <member name="M:Parse.ParseUser.BecomeAsync(System.String,System.Threading.CancellationToken)">

            Logs in a user with a username and password. On success, this saves the session to disk so you
            can retrieve the currently logged in user using <see cref="P:Parse.ParseUser.CurrentUser"/>.

            <param name="sessionToken">The session token to authorize with</param>
            <param name="cancellationToken">The cancellation token.</param>
            <returns>The user if authorization was successful</returns>
        </member>
        <member name="M:Parse.ParseUser.LogOut">

            Logs out the currently logged in user session. This will remove the session from disk, log out of
            linked services, and future calls to <see cref="P:Parse.ParseUser.CurrentUser"/> will return <c>null</c>.

            <remarks>
            Typically, you should use <see cref="M:Parse.ParseUser.LogOutAsync"/>, unless you are managing your own threading.
            </remarks>
        </member>
        <member name="M:Parse.ParseUser.LogOutAsync">

            Logs out the currently logged in user session. This will remove the session from disk, log out of
            linked services, and future calls to <see cref="P:Parse.ParseUser.CurrentUser"/> will return <c>null</c>.

            <remarks>
            This is preferable to using <see cref="M:Parse.ParseUser.LogOut"/>, unless your code is already running from a
            background thread.
            </remarks>
        </member>
        <member name="M:Parse.ParseUser.LogOutAsync(System.Threading.CancellationToken)">

            Logs out the currently logged in user session. This will remove the session from disk, log out of
            linked services, and future calls to <see cref="P:Parse.ParseUser.CurrentUser"/> will return <c>null</c>.

            This is preferable to using <see cref="M:Parse.ParseUser.LogOut"/>, unless your code is already running from a
            background thread.

        </member>
        <member name="P:Parse.ParseUser.CurrentUser">

            Gets the currently logged in ParseUser with a valid session, either from memory or disk
            if necessary.

        </member>
        <member name="M:Parse.ParseUser.GetCurrentUserAsync">

            Gets the currently logged in ParseUser with a valid session, either from memory or disk
            if necessary, asynchronously.

        </member>
        <member name="M:Parse.ParseUser.GetCurrentUserAsync(System.Threading.CancellationToken)">

            Gets the currently logged in ParseUser with a valid session, either from memory or disk
            if necessary, asynchronously.

        </member>
        <member name="P:Parse.ParseUser.Query">

            Constructs a <see cref="T:Parse.ParseQuery`1"/> for ParseUsers.

        </member>
        <member name="M:Parse.ParseUser.EnableRevocableSessionAsync">

            Tells server to use revocable session on LogIn and SignUp, even when App's Settings
            has "Require Revocable Session" turned off. Issues network request in background to
            migrate the sessionToken on disk to revocable session.

            <returns>The Task that upgrades the session.</returns>
        </member>
        <member name="M:Parse.ParseUser.EnableRevocableSessionAsync(System.Threading.CancellationToken)">

            Tells server to use revocable session on LogIn and SignUp, even when App's Settings
            has "Require Revocable Session" turned off. Issues network request in background to
            migrate the sessionToken on disk to revocable session.

            <returns>The Task that upgrades the session.</returns>
        </member>
        <member name="M:Parse.ParseUser.RequestPasswordResetAsync(System.String)">

            Requests a password reset email to be sent to the specified email address associated with the
            user account. This email allows the user to securely reset their password on the Parse site.

            <param name="email">The email address associated with the user that forgot their password.</param>
        </member>
        <member name="M:Parse.ParseUser.RequestPasswordResetAsync(System.String,System.Threading.CancellationToken)">

            Requests a password reset email to be sent to the specified email address associated with the
            user account. This email allows the user to securely reset their password on the Parse site.

            <param name="email">The email address associated with the user that forgot their password.</param>
            <param name="cancellationToken">The cancellation token.</param>
        </member>
        <member name="P:Parse.ParseUser.AuthData">

            Gets the authData for this user.

        </member>
        <member name="M:Parse.ParseUser.CleanupAuthData">

            Removes null values from authData (which exist temporarily for unlinking)

        </member>
        <member name="M:Parse.ParseUser.SynchronizeAllAuthData">

            Synchronizes authData for all providers.

        </member>
        <member name="M:Parse.ParseUser.UnlinkFromAsync(System.String,System.Threading.CancellationToken)">

            Unlinks a user from a service.

        </member>
        <member name="M:Parse.ParseUser.IsLinked(System.String)">

            Checks whether a user is linked to a service.

        </member>
    </members>
</doc>