<?xml version="1.0" encoding="utf-8"?>
<doc>
    <assembly>
        <name>Microsoft.Toolkit.Mvvm</name>
    </assembly>
    <members>
        <member name="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject">
            <summary>
            A base class for objects of which the properties must be observable.
            </summary>
        </member>
        <member name="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" />
        <member name="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" />
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.OnPropertyChanged(System.ComponentModel.PropertyChangedEventArgs)">
            <summary>
            Raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            </summary>
            <param name="e">The input <see cref="T:System.ComponentModel.PropertyChangedEventArgs" /> instance.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.OnPropertyChanging(System.ComponentModel.PropertyChangingEventArgs)">
            <summary>
            Raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event.
            </summary>
            <param name="e">The input <see cref="T:System.ComponentModel.PropertyChangingEventArgs" /> instance.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.OnPropertyChanged(System.String)">
            <summary>
            Raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            </summary>
            <param name="propertyName">(optional) The name of the property that changed.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.OnPropertyChanging(System.String)">
            <summary>
            Raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event.
            </summary>
            <param name="propertyName">(optional) The name of the property that changed.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.String)">
            <summary>
            Compares the current and new values for a given property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property with the new
            value, then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="field">The field storing the property's value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
            <remarks>
            The <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> and <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> events are not raised
            if the current and new value for the target property are the same.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.Collections.Generic.IEqualityComparer{``0},System.String)">
            <summary>
            Compares the current and new values for a given property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property with the new
            value, then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            See additional notes about this overload in <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.String)" />.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="field">The field storing the property's value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> instance to use to compare the input values.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0,``0,System.Action{``0},System.String)">
            <summary>
            Compares the current and new values for a given property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property with the new
            value, then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            This overload is much less efficient than <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.String)" /> and it
            should only be used when the former is not viable (eg. when the target property being
            updated does not directly expose a backing field that can be passed by reference).
            For performance reasons, it is recommended to use a stateful callback if possible through
            the <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,``0,System.Action{``0,``1},System.String)" /> whenever possible
            instead of this overload, as that will allow the C# compiler to cache the input callback and
            reduce the memory allocations. More info on that overload are available in the related XML
            docs. This overload is here for completeness and in cases where that is not applicable.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="callback">A callback to invoke to update the property value.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
            <remarks>
            The <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> and <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> events are not raised
            if the current and new value for the target property are the same.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0,``0,System.Collections.Generic.IEqualityComparer{``0},System.Action{``0},System.String)">
            <summary>
            Compares the current and new values for a given property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property with the new
            value, then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            See additional notes about this overload in <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0,``0,System.Action{``0},System.String)" />.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> instance to use to compare the input values.</param>
            <param name="callback">A callback to invoke to update the property value.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,``0,System.Action{``0,``1},System.String)">
            <summary>
             Compares the current and new values for a given nested property. If the value has changed,
             raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property and then raises the
             <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event. The behavior mirrors that of <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.String)" />,
             with the difference being that this method is used to relay properties from a wrapped model in the
             current instance. This type is useful when creating wrapping, bindable objects that operate over
             models that lack support for notification (eg. for CRUD operations).
             Suppose we have this model (eg. for a database row in a table):
             <code>
             public class Person
             {
                 public string Name { get; set; }
             }
             </code>
             We can then use a property to wrap instances of this type into our observable model (which supports
             notifications), injecting the notification to the properties of that model, like so:
             <code>
             public class BindablePerson : ObservableObject
             {
                 public Model { get; }
            
                 public BindablePerson(Person model)
                 {
                     Model = model;
                 }
            
                 public string Name
                 {
                     get =&gt; Model.Name;
                     set =&gt; Set(Model.Name, value, Model, (model, name) =&gt; model.Name = name);
                 }
             }
             </code>
             This way we can then use the wrapping object in our application, and all those "proxy" properties will
             also raise notifications when changed. Note that this method is not meant to be a replacement for
             <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.String)" />, and it should only be used when relaying properties to a model that
             doesn't support notifications, and only if you can't implement notifications to that model directly (eg. by having
             it inherit from <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject" />). The syntax relies on passing the target model and a stateless callback
             to allow the C# compiler to cache the function, which results in much better performance and no memory usage.
             </summary>
            <typeparam name="TModel">The type of model whose property (or field) to set.</typeparam>
            <typeparam name="T">The type of property (or field) to set.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="model">The model containing the property being updated.</param>
            <param name="callback">The callback to invoke to set the target property value, if a change has occurred.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
            <remarks>
             The <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> and <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> events are not
             raised if the current and new value for the target property are the same.
             </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,System.Collections.Generic.IEqualityComparer{``1},``0,System.Action{``0,``1},System.String)">
            <summary>
            Compares the current and new values for a given nested property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property and then raises the
            <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event. The behavior mirrors that of <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.String)" />,
            with the difference being that this method is used to relay properties from a wrapped model in the
            current instance. See additional notes about this overload in <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,``0,System.Action{``0,``1},System.String)" />.
            </summary>
            <typeparam name="TModel">The type of model whose property (or field) to set.</typeparam>
            <typeparam name="T">The type of property (or field) to set.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> instance to use to compare the input values.</param>
            <param name="model">The model containing the property being updated.</param>
            <param name="callback">The callback to invoke to set the target property value, if a change has occurred.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetPropertyAndNotifyOnCompletion(Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier@,System.Threading.Tasks.Task,System.String)">
            <summary>
             Compares the current and new values for a given field (which should be the backing
             field for a property). If the value has changed, raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" />
             event, updates the field and then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
             The behavior mirrors that of <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.String)" />, with the difference being that
             this method will also monitor the new value of the property (a generic <see cref="T:System.Threading.Tasks.Task" />) and will also
             raise the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> again for the target property when it completes.
             This can be used to update bindings observing that <see cref="T:System.Threading.Tasks.Task" /> or any of its properties.
             This method and its overload specifically rely on the <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier" /> type, which needs
             to be used in the backing field for the target <see cref="T:System.Threading.Tasks.Task" /> property. The field doesn't need to be
             initialized, as this method will take care of doing that automatically. The <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier" />
             type also includes an implicit operator, so it can be assigned to any <see cref="T:System.Threading.Tasks.Task" /> instance directly.
             Here is a sample property declaration using this method:
             <code>
             private TaskNotifier myTask;
            
             public Task MyTask
             {
                 get =&gt; myTask;
                 private set =&gt; SetAndNotifyOnCompletion(ref myTask, value);
             }
             </code></summary>
            <param name="taskNotifier">The field notifier to modify.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
            <remarks>
             The <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> and <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> events are not raised if the current
             and new value for the target property are the same. The return value being <see langword="true" /> only
             indicates that the new value being assigned to <paramref name="taskNotifier" /> is different than the previous one,
             and it does not mean the new <see cref="T:System.Threading.Tasks.Task" /> instance passed as argument is in any particular state.
             </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetPropertyAndNotifyOnCompletion(Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier@,System.Threading.Tasks.Task,System.Action{System.Threading.Tasks.Task},System.String)">
            <summary>
            Compares the current and new values for a given field (which should be the backing
            field for a property). If the value has changed, raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" />
            event, updates the field and then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            This method is just like <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetPropertyAndNotifyOnCompletion(Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier@,System.Threading.Tasks.Task,System.String)" />,
            with the difference being an extra <see cref="T:System.Action`1" /> parameter with a callback being invoked
            either immediately, if the new task has already completed or is <see langword="null" />, or upon completion.
            </summary>
            <param name="taskNotifier">The field notifier to modify.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="callback">A callback to invoke to update the property value.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
            <remarks>
            The <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> and <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> events are not raised
            if the current and new value for the target property are the same.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetPropertyAndNotifyOnCompletion``1(Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier{``0}@,System.Threading.Tasks.Task{``0},System.String)">
            <summary>
             Compares the current and new values for a given field (which should be the backing
             field for a property). If the value has changed, raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" />
             event, updates the field and then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
             The behavior mirrors that of <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.String)" />, with the difference being that
             this method will also monitor the new value of the property (a generic <see cref="T:System.Threading.Tasks.Task" />) and will also
             raise the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> again for the target property when it completes.
             This can be used to update bindings observing that <see cref="T:System.Threading.Tasks.Task" /> or any of its properties.
             This method and its overload specifically rely on the <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier`1" /> type, which needs
             to be used in the backing field for the target <see cref="T:System.Threading.Tasks.Task" /> property. The field doesn't need to be
             initialized, as this method will take care of doing that automatically. The <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier`1" />
             type also includes an implicit operator, so it can be assigned to any <see cref="T:System.Threading.Tasks.Task" /> instance directly.
             Here is a sample property declaration using this method:
             <code>
             private TaskNotifier&lt;int&gt; myTask;
            
             public Task&lt;int&gt; MyTask
             {
                 get =&gt; myTask;
                 private set =&gt; SetAndNotifyOnCompletion(ref myTask, value);
             }
             </code></summary>
            <typeparam name="T">The type of result for the <see cref="T:System.Threading.Tasks.Task`1" /> to set and monitor.</typeparam>
            <param name="taskNotifier">The field notifier to modify.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
            <remarks>
             The <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> and <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> events are not raised if the current
             and new value for the target property are the same. The return value being <see langword="true" /> only
             indicates that the new value being assigned to <paramref name="taskNotifier" /> is different than the previous one,
             and it does not mean the new <see cref="T:System.Threading.Tasks.Task`1" /> instance passed as argument is in any particular state.
             </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetPropertyAndNotifyOnCompletion``1(Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier{``0}@,System.Threading.Tasks.Task{``0},System.Action{System.Threading.Tasks.Task{``0}},System.String)">
            <summary>
            Compares the current and new values for a given field (which should be the backing
            field for a property). If the value has changed, raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" />
            event, updates the field and then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            This method is just like <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetPropertyAndNotifyOnCompletion``1(Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier{``0}@,System.Threading.Tasks.Task{``0},System.String)" />,
            with the difference being an extra <see cref="T:System.Action`1" /> parameter with a callback being invoked
            either immediately, if the new task has already completed or is <see langword="null" />, or upon completion.
            </summary>
            <typeparam name="T">The type of result for the <see cref="T:System.Threading.Tasks.Task`1" /> to set and monitor.</typeparam>
            <param name="taskNotifier">The field notifier to modify.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="callback">A callback to invoke to update the property value.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
            <remarks>
            The <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> and <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> events are not raised
            if the current and new value for the target property are the same.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetPropertyAndNotifyOnCompletion``1(Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.ITaskNotifier{``0},``0,System.Action{``0},System.String)">
            <summary>
            Implements the notification logic for the related methods.
            </summary>
            <typeparam name="TTask">The type of <see cref="T:System.Threading.Tasks.Task" /> to set and monitor.</typeparam>
            <param name="taskNotifier">The field notifier.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="callback">A callback to invoke to update the property value.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.ITaskNotifier`1">
            <summary>
            An interface for task notifiers of a specified type.
            </summary>
            <typeparam name="TTask">The type of value to store.</typeparam>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.ITaskNotifier`1.Task">
            <summary>
            Gets or sets the wrapped <typeparamref name="TTask" /> value.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier">
            <summary>
            A wrapping class that can hold a <see cref="T:System.Threading.Tasks.Task" /> value.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier" /> class.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier.Microsoft#Toolkit#Mvvm#ComponentModel#ObservableObject#ITaskNotifier{System#Threading#Tasks#Task}#Task" />
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier.op_Implicit(Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier)~System.Threading.Tasks.Task">
            <summary>
            Unwraps the <see cref="T:System.Threading.Tasks.Task" /> value stored in the current instance.
            </summary>
            <param name="notifier">The input <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier`1" /> instance.</param>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier`1">
            <summary>
            A wrapping class that can hold a <see cref="T:System.Threading.Tasks.Task`1" /> value.
            </summary>
            <typeparam name="T">The type of value for the wrapped <see cref="T:System.Threading.Tasks.Task`1" /> instance.</typeparam>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier`1.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier`1" /> class.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier`1.Microsoft#Toolkit#Mvvm#ComponentModel#ObservableObject#ITaskNotifier{System#Threading#Tasks#Task{T}}#Task" />
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier`1.op_Implicit(Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier{`0})~System.Threading.Tasks.Task{`0}">
            <summary>
            Unwraps the <see cref="T:System.Threading.Tasks.Task`1" /> value stored in the current instance.
            </summary>
            <param name="notifier">The input <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.TaskNotifier`1" /> instance.</param>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient">
            <summary>
            A base class for observable objects that also acts as recipients for messages. This class is an extension of
            <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject" /> which also provides built-in support to use the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> type.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient" /> class.
            </summary>
            <remarks>
            This constructor will produce an instance that will use the <see cref="P:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.Default" /> instance
            to perform requested operations. It will also be available locally through the <see cref="P:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.Messenger" /> property.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.#ctor(Microsoft.Toolkit.Mvvm.Messaging.IMessenger)">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient" /> class.
            </summary>
            <param name="messenger">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance to use to send messages.</param>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.Messenger">
            <summary>
            Gets the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance in use.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.IsActive">
            <summary>
            Gets or sets a value indicating whether the current view model is currently active.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.OnActivated">
            <summary>
            Raised whenever the <see cref="P:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.IsActive" /> property is set to <see langword="true" />.
            Use this method to register to messages and do other initialization for this instance.
            </summary>
            <remarks>
            The base implementation registers all messages for this recipients that have been declared
            explicitly through the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IRecipient`1" /> interface, using the default channel.
            For more details on how this works, see the <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.RegisterAll(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,System.Object)" /> method.
            If you need more fine tuned control, want to register messages individually or just prefer
            the lambda-style syntax for message registration, override this method and register manually.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.OnDeactivated">
            <summary>
            Raised whenever the <see cref="P:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.IsActive" /> property is set to <see langword="false" />.
            Use this method to unregister from messages and do general cleanup for this instance.
            </summary>
            <remarks>
            The base implementation unregisters all messages for this recipient. It does so by
            invoking <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.IMessenger.UnregisterAll(System.Object)" />, which removes all registered
            handlers for a given subscriber, regardless of what token was used to register them.
            That is, all registered handlers across all subscription channels will be removed.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.Broadcast``1(``0,``0,System.String)">
            <summary>
            Broadcasts a <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.Messages.PropertyChangedMessage`1" /> with the specified
            parameters, without using any particular token (so using the default channel).
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="oldValue">The value of the property before it changed.</param>
            <param name="newValue">The value of the property after it changed.</param>
            <param name="propertyName">The name of the property that changed.</param>
            <remarks>
            You should override this method if you wish to customize the channel being
            used to send the message (eg. if you need to use a specific token for the channel).
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.SetProperty``1(``0@,``0,System.Boolean,System.String)">
            <summary>
            Compares the current and new values for a given property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property with
            the new value, then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="field">The field storing the property's value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="broadcast">If <see langword="true" />, <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.Broadcast``1(``0,``0,System.String)" /> will also be invoked.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
            <remarks>
            This method is just like <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.String)" />, just with the addition
            of the <paramref name="broadcast" /> parameter. As such, following the behavior of the base method,
            the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> and <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> events
            are not raised if the current and new value for the target property are the same.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.SetProperty``1(``0@,``0,System.Collections.Generic.IEqualityComparer{``0},System.Boolean,System.String)">
            <summary>
            Compares the current and new values for a given property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property with
            the new value, then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            See additional notes about this overload in <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.SetProperty``1(``0@,``0,System.Boolean,System.String)" />.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="field">The field storing the property's value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> instance to use to compare the input values.</param>
            <param name="broadcast">If <see langword="true" />, <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.Broadcast``1(``0,``0,System.String)" /> will also be invoked.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.SetProperty``1(``0,``0,System.Action{``0},System.Boolean,System.String)">
            <summary>
            Compares the current and new values for a given property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property with
            the new value, then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event. Similarly to
            the <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0,``0,System.Action{``0},System.String)" /> method, this overload should only be
            used when <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.String)" /> can't be used directly.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="callback">A callback to invoke to update the property value.</param>
            <param name="broadcast">If <see langword="true" />, <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.Broadcast``1(``0,``0,System.String)" /> will also be invoked.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
            <remarks>
            This method is just like <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0,``0,System.Action{``0},System.String)" />, just with the addition
            of the <paramref name="broadcast" /> parameter. As such, following the behavior of the base method,
            the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> and <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> events
            are not raised if the current and new value for the target property are the same.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.SetProperty``1(``0,``0,System.Collections.Generic.IEqualityComparer{``0},System.Action{``0},System.Boolean,System.String)">
            <summary>
            Compares the current and new values for a given property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property with
            the new value, then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            See additional notes about this overload in <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.SetProperty``1(``0,``0,System.Action{``0},System.Boolean,System.String)" />.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> instance to use to compare the input values.</param>
            <param name="callback">A callback to invoke to update the property value.</param>
            <param name="broadcast">If <see langword="true" />, <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.Broadcast``1(``0,``0,System.String)" /> will also be invoked.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.SetProperty``2(``1,``1,``0,System.Action{``0,``1},System.Boolean,System.String)">
            <summary>
            Compares the current and new values for a given nested property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property and then raises the
            <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event. The behavior mirrors that of
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,``0,System.Action{``0,``1},System.String)" />, with the difference being that this
            method is used to relay properties from a wrapped model in the current instance. For more info, see the docs for
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,``0,System.Action{``0,``1},System.String)" />.
            </summary>
            <typeparam name="TModel">The type of model whose property (or field) to set.</typeparam>
            <typeparam name="T">The type of property (or field) to set.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="model">The model </param>
            <param name="callback">The callback to invoke to set the target property value, if a change has occurred.</param>
            <param name="broadcast">If <see langword="true" />, <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.Broadcast``1(``0,``0,System.String)" /> will also be invoked.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.SetProperty``2(``1,``1,System.Collections.Generic.IEqualityComparer{``1},``0,System.Action{``0,``1},System.Boolean,System.String)">
            <summary>
            Compares the current and new values for a given nested property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property and then raises the
            <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event. The behavior mirrors that of
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,System.Collections.Generic.IEqualityComparer{``1},``0,System.Action{``0,``1},System.String)" />,
            with the difference being that this method is used to relay properties from a wrapped model in the
            current instance. For more info, see the docs for
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,System.Collections.Generic.IEqualityComparer{``1},``0,System.Action{``0,``1},System.String)" />.
            </summary>
            <typeparam name="TModel">The type of model whose property (or field) to set.</typeparam>
            <typeparam name="T">The type of property (or field) to set.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> instance to use to compare the input values.</param>
            <param name="model">The model </param>
            <param name="callback">The callback to invoke to set the target property value, if a change has occurred.</param>
            <param name="broadcast">If <see langword="true" />, <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableRecipient.Broadcast``1(``0,``0,System.String)" /> will also be invoked.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator">
            <summary>
            A base class for objects implementing the <see cref="T:System.ComponentModel.INotifyDataErrorInfo" /> interface. This class
            also inherits from <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject" />, so it can be used for observable items too.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.EntityValidatorMap">
            <summary>
            The <see cref="T:System.Runtime.CompilerServices.ConditionalWeakTable`2" /> instance used to track compiled delegates to validate entities.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.DisplayNamesMap">
            <summary>
            The <see cref="T:System.Runtime.CompilerServices.ConditionalWeakTable`2" /> instance used to track display names for properties to validate.
            </summary>
            <remarks>
            This is necessary because we want to reuse the same <see cref="T:System.ComponentModel.DataAnnotations.ValidationContext" /> instance for all validations, but
            with the same behavior with repsect to formatted names that new instances would have provided. The issue is that the
            <see cref="P:System.ComponentModel.DataAnnotations.ValidationContext.DisplayName" /> property is not refreshed when we set <see cref="P:System.ComponentModel.DataAnnotations.ValidationContext.MemberName" />,
            so we need to replicate the same logic to retrieve the right display name for properties to validate and update that
            property manually right before passing the context to <see cref="T:System.ComponentModel.DataAnnotations.Validator" /> and proceed with the normal functionality.
            </remarks>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.HasErrorsChangedEventArgs">
            <summary>
            The cached <see cref="T:System.ComponentModel.PropertyChangedEventArgs" /> for <see cref="P:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.HasErrors" />.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.validationContext">
            <summary>
            The <see cref="T:System.ComponentModel.DataAnnotations.ValidationContext" /> instance currenty in use.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.errors">
            <summary>
            The <see cref="T:System.Collections.Generic.Dictionary`2" /> instance used to store previous validation results.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.totalErrors">
            <summary>
            Indicates the total number of properties with errors (not total errors).
            This is used to allow <see cref="P:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.HasErrors" /> to operate in O(1) time, as it can just
            check whether this value is not 0 instead of having to traverse <see cref="F:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.errors" />.
            </summary>
        </member>
        <member name="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.ErrorsChanged" />
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator" /> class.
            This constructor will create a new <see cref="T:System.ComponentModel.DataAnnotations.ValidationContext" /> that will
            be used to validate all properties, which will reference the current instance
            and no additional services or validation properties and settings.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.#ctor(System.Collections.Generic.IDictionary{System.Object,System.Object})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator" /> class.
            This constructor will create a new <see cref="T:System.ComponentModel.DataAnnotations.ValidationContext" /> that will
            be used to validate all properties, which will reference the current instance.
            </summary>
            <param name="items">A set of key/value pairs to make available to consumers.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.#ctor(System.IServiceProvider,System.Collections.Generic.IDictionary{System.Object,System.Object})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator" /> class.
            This constructor will create a new <see cref="T:System.ComponentModel.DataAnnotations.ValidationContext" /> that will
            be used to validate all properties, which will reference the current instance.
            </summary>
            <param name="serviceProvider">An <see cref="T:System.IServiceProvider" /> instance to make available during validation.</param>
            <param name="items">A set of key/value pairs to make available to consumers.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.#ctor(System.ComponentModel.DataAnnotations.ValidationContext)">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator" /> class.
            This constructor will store the input <see cref="T:System.ComponentModel.DataAnnotations.ValidationContext" /> instance,
            and it will use it to validate all properties for the current viewmodel.
            </summary>
            <param name="validationContext">
            The <see cref="T:System.ComponentModel.DataAnnotations.ValidationContext" /> instance to use to validate properties.
            <para>
            This instance will be passed to all <see cref="M:System.ComponentModel.DataAnnotations.Validator.TryValidateObject(System.Object,System.ComponentModel.DataAnnotations.ValidationContext,System.Collections.Generic.ICollection{System.ComponentModel.DataAnnotations.ValidationResult})" />
            calls executed by the current viewmodel, and its <see cref="P:System.ComponentModel.DataAnnotations.ValidationContext.MemberName" /> property will be updated every time
            before the call is made to set the name of the property being validated. The property name will not be reset after that, so the
            value of <see cref="P:System.ComponentModel.DataAnnotations.ValidationContext.MemberName" /> will always indicate the name of the last property that was validated, if any.
            </para></param>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.HasErrors" />
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.SetProperty``1(``0@,``0,System.Boolean,System.String)">
            <summary>
            Compares the current and new values for a given property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property with
            the new value, then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="field">The field storing the property's value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="validate">If <see langword="true" />, <paramref name="newValue" /> will also be validated.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
            <remarks>
            This method is just like <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.String)" />, just with the addition
            of the <paramref name="validate" /> parameter. If that is set to <see langword="true" />, the new value will be
            validated and <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.ErrorsChanged" /> will be raised if needed. Following the behavior of the base method,
            the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> and <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> events
            are not raised if the current and new value for the target property are the same.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.SetProperty``1(``0@,``0,System.Collections.Generic.IEqualityComparer{``0},System.Boolean,System.String)">
            <summary>
            Compares the current and new values for a given property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property with
            the new value, then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            See additional notes about this overload in <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.SetProperty``1(``0@,``0,System.Boolean,System.String)" />.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="field">The field storing the property's value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> instance to use to compare the input values.</param>
            <param name="validate">If <see langword="true" />, <paramref name="newValue" /> will also be validated.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.SetProperty``1(``0,``0,System.Action{``0},System.Boolean,System.String)">
            <summary>
            Compares the current and new values for a given property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property with
            the new value, then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event. Similarly to
            the <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0,``0,System.Action{``0},System.String)" /> method, this overload should only be
            used when <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.String)" /> can't be used directly.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="callback">A callback to invoke to update the property value.</param>
            <param name="validate">If <see langword="true" />, <paramref name="newValue" /> will also be validated.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
            <remarks>
            This method is just like <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0,``0,System.Action{``0},System.String)" />, just with the addition
            of the <paramref name="validate" /> parameter. As such, following the behavior of the base method,
            the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> and <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> events
            are not raised if the current and new value for the target property are the same.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.SetProperty``1(``0,``0,System.Collections.Generic.IEqualityComparer{``0},System.Action{``0},System.Boolean,System.String)">
            <summary>
            Compares the current and new values for a given property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property with
            the new value, then raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event.
            See additional notes about this overload in <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.SetProperty``1(``0,``0,System.Action{``0},System.Boolean,System.String)" />.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> instance to use to compare the input values.</param>
            <param name="callback">A callback to invoke to update the property value.</param>
            <param name="validate">If <see langword="true" />, <paramref name="newValue" /> will also be validated.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.SetProperty``2(``1,``1,``0,System.Action{``0,``1},System.Boolean,System.String)">
            <summary>
            Compares the current and new values for a given nested property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property and then raises the
            <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event. The behavior mirrors that of
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,``0,System.Action{``0,``1},System.String)" />, with the difference being that this
            method is used to relay properties from a wrapped model in the current instance. For more info, see the docs for
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,``0,System.Action{``0,``1},System.String)" />.
            </summary>
            <typeparam name="TModel">The type of model whose property (or field) to set.</typeparam>
            <typeparam name="T">The type of property (or field) to set.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="model">The model </param>
            <param name="callback">The callback to invoke to set the target property value, if a change has occurred.</param>
            <param name="validate">If <see langword="true" />, <paramref name="newValue" /> will also be validated.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.SetProperty``2(``1,``1,System.Collections.Generic.IEqualityComparer{``1},``0,System.Action{``0,``1},System.Boolean,System.String)">
            <summary>
            Compares the current and new values for a given nested property. If the value has changed,
            raises the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanging" /> event, updates the property and then raises the
            <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.PropertyChanged" /> event. The behavior mirrors that of
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,System.Collections.Generic.IEqualityComparer{``1},``0,System.Action{``0,``1},System.String)" />,
            with the difference being that this method is used to relay properties from a wrapped model in the
            current instance. For more info, see the docs for
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,System.Collections.Generic.IEqualityComparer{``1},``0,System.Action{``0,``1},System.String)" />.
            </summary>
            <typeparam name="TModel">The type of model whose property (or field) to set.</typeparam>
            <typeparam name="T">The type of property (or field) to set.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> instance to use to compare the input values.</param>
            <param name="model">The model </param>
            <param name="callback">The callback to invoke to set the target property value, if a change has occurred.</param>
            <param name="validate">If <see langword="true" />, <paramref name="newValue" /> will also be validated.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>
                <see langword="true" /> if the property was changed, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.TrySetProperty``1(``0@,``0,System.Collections.Generic.IReadOnlyCollection{System.ComponentModel.DataAnnotations.ValidationResult}@,System.String)">
            <summary>
            Tries to validate a new value for a specified property. If the validation is successful,
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.String)" /> is called, otherwise no state change is performed.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="field">The field storing the property's value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="errors">The resulting validation errors, if any.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>Whether the validation was successful and the property value changed as well.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.TrySetProperty``1(``0@,``0,System.Collections.Generic.IEqualityComparer{``0},System.Collections.Generic.IReadOnlyCollection{System.ComponentModel.DataAnnotations.ValidationResult}@,System.String)">
            <summary>
            Tries to validate a new value for a specified property. If the validation is successful,
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0@,``0,System.Collections.Generic.IEqualityComparer{``0},System.String)" /> is called, otherwise no state change is performed.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="field">The field storing the property's value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> instance to use to compare the input values.</param>
            <param name="errors">The resulting validation errors, if any.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>Whether the validation was successful and the property value changed as well.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.TrySetProperty``1(``0,``0,System.Action{``0},System.Collections.Generic.IReadOnlyCollection{System.ComponentModel.DataAnnotations.ValidationResult}@,System.String)">
            <summary>
            Tries to validate a new value for a specified property. If the validation is successful,
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0,``0,System.Action{``0},System.String)" /> is called, otherwise no state change is performed.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="callback">A callback to invoke to update the property value.</param>
            <param name="errors">The resulting validation errors, if any.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>Whether the validation was successful and the property value changed as well.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.TrySetProperty``1(``0,``0,System.Collections.Generic.IEqualityComparer{``0},System.Action{``0},System.Collections.Generic.IReadOnlyCollection{System.ComponentModel.DataAnnotations.ValidationResult}@,System.String)">
            <summary>
            Tries to validate a new value for a specified property. If the validation is successful,
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``1(``0,``0,System.Collections.Generic.IEqualityComparer{``0},System.Action{``0},System.String)" /> is called, otherwise no state change is performed.
            </summary>
            <typeparam name="T">The type of the property that changed.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> instance to use to compare the input values.</param>
            <param name="callback">A callback to invoke to update the property value.</param>
            <param name="errors">The resulting validation errors, if any.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>Whether the validation was successful and the property value changed as well.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.TrySetProperty``2(``1,``1,``0,System.Action{``0,``1},System.Collections.Generic.IReadOnlyCollection{System.ComponentModel.DataAnnotations.ValidationResult}@,System.String)">
            <summary>
            Tries to validate a new value for a specified property. If the validation is successful,
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,``0,System.Action{``0,``1},System.String)" /> is called, otherwise no state change is performed.
            </summary>
            <typeparam name="TModel">The type of model whose property (or field) to set.</typeparam>
            <typeparam name="T">The type of property (or field) to set.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="model">The model </param>
            <param name="callback">The callback to invoke to set the target property value, if a change has occurred.</param>
            <param name="errors">The resulting validation errors, if any.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>Whether the validation was successful and the property value changed as well.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.TrySetProperty``2(``1,``1,System.Collections.Generic.IEqualityComparer{``1},``0,System.Action{``0,``1},System.Collections.Generic.IReadOnlyCollection{System.ComponentModel.DataAnnotations.ValidationResult}@,System.String)">
            <summary>
            Tries to validate a new value for a specified property. If the validation is successful,
            <see cref="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableObject.SetProperty``2(``1,``1,System.Collections.Generic.IEqualityComparer{``1},``0,System.Action{``0,``1},System.String)" /> is called, otherwise no state change is performed.
            </summary>
            <typeparam name="TModel">The type of model whose property (or field) to set.</typeparam>
            <typeparam name="T">The type of property (or field) to set.</typeparam>
            <param name="oldValue">The current property value.</param>
            <param name="newValue">The property's value after the change occurred.</param>
            <param name="comparer">The <see cref="T:System.Collections.Generic.IEqualityComparer`1" /> instance to use to compare the input values.</param>
            <param name="model">The model </param>
            <param name="callback">The callback to invoke to set the target property value, if a change has occurred.</param>
            <param name="errors">The resulting validation errors, if any.</param>
            <param name="propertyName">(optional) The name of the property that changed.</param>
            <returns>Whether the validation was successful and the property value changed as well.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.ClearErrors(System.String)">
            <summary>
            Clears the validation errors for a specified property or for the entire entity.
            </summary>
            <param name="propertyName">
            The name of the property to clear validation errors for.
            If a <see langword="null" /> or empty name is used, all entity-level errors will be cleared.
            </param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.GetErrors(System.String)" />
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.System#ComponentModel#INotifyDataErrorInfo#GetErrors(System.String)" />
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.ValidateAllProperties">
            <summary>
            Validates all the properties in the current instance and updates all the tracked errors.
            If any changes are detected, the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.ErrorsChanged" /> event will be raised.
            </summary>
            <remarks>
            Only public instance properties (excluding custom indexers) that have at least one
            <see cref="T:System.ComponentModel.DataAnnotations.ValidationAttribute" /> applied to them will be validated. All other
            members in the current instance will be ignored. None of the processed properties
            will be modified - they will only be used to retrieve their values and validate them.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.ValidateProperty(System.Object,System.String)">
            <summary>
            Validates a property with a specified name and a given input value.
            If any changes are detected, the <see cref="E:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.ErrorsChanged" /> event will be raised.
            </summary>
            <param name="value">The value to test for the specified property.</param>
            <param name="propertyName">The name of the property to validate.</param>
            <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="propertyName" /> is <see langword="null" />.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.TryValidateProperty(System.Object,System.String,System.Collections.Generic.IReadOnlyCollection{System.ComponentModel.DataAnnotations.ValidationResult}@)">
            <summary>
            Tries to validate a property with a specified name and a given input value, and returns
            the computed errors, if any. If the property is valid, it is assumed that its value is
            about to be set in the current object. Otherwise, no observable local state is modified.
            </summary>
            <param name="value">The value to test for the specified property.</param>
            <param name="propertyName">The name of the property to validate.</param>
            <param name="errors">The resulting validation errors, if any.</param>
            <exception cref="T:System.ArgumentNullException">Thrown when <paramref name="propertyName" /> is <see langword="null" />.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.ClearAllErrors">
            <summary>
            Clears all the current errors for the entire entity.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.ClearErrorsForProperty(System.String)">
            <summary>
            Clears all the current errors for a target property.
            </summary>
            <param name="propertyName">The name of the property to clear errors for.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.GetDisplayNameForProperty(System.String)">
            <summary>
            Gets the display name for a given property. It could be a custom name or just the property name.
            </summary>
            <param name="propertyName">The target property name being validated.</param>
            <returns>The display name for the property.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.ComponentModel.ObservableValidator.ThrowArgumentNullExceptionForNullPropertyName">
            <summary>
            Throws an <see cref="T:System.ArgumentNullException" /> when a property name given as input is <see langword="null" />.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc">
            <summary>
            A type that facilitates the use of the <see cref="T:System.IServiceProvider" /> type.
            The <see cref="T:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc" /> provides the ability to configure services in a singleton, thread-safe
            service provider instance, which can then be used to resolve service instances.
            The first step to use this feature is to declare some services, for instance:
            <code>
            public interface ILogger
            {
                void Log(string text);
            }
            </code><code>
            public class ConsoleLogger : ILogger
            {
                void Log(string text) =&gt; Console.WriteLine(text);
            }
            </code>
            Then the services configuration should then be done at startup, by calling the <see cref="M:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc.ConfigureServices(System.IServiceProvider)" />
            method and passing an <see cref="T:System.IServiceProvider" /> instance with the services to use. That instance can
            be from any library offering dependency injection functionality, such as Microsoft.Extensions.DependencyInjection.
            For instance, using that library, <see cref="M:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc.ConfigureServices(System.IServiceProvider)" /> can be used as follows in this example:
            <code>
            Ioc.Default.ConfigureServices(
                new ServiceCollection()
                .AddSingleton&lt;ILogger, Logger&gt;()
                .BuildServiceProvider());
            </code>
            Finally, you can use the <see cref="T:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc" /> instance (which implements <see cref="T:System.IServiceProvider" />)
            to retrieve the service instances from anywhere in your application, by doing as follows:
            <code>
            Ioc.Default.GetService&lt;ILogger&gt;().Log("Hello world!");
            </code></summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc.Default">
            <summary>
            Gets the default <see cref="T:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc" /> instance.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc.serviceProvider">
            <summary>
            The <see cref="T:System.IServiceProvider" /> instance to use, if initialized.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc.GetService(System.Type)" />
        <member name="M:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc.GetService``1">
            <summary>
            Tries to resolve an instance of a specified service type.
            </summary>
            <typeparam name="T">The type of service to resolve.</typeparam>
            <returns>An instance of the specified service, or <see langword="null" />.</returns>
            <exception cref="T:System.InvalidOperationException">Throw if the current <see cref="T:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc" /> instance has not been initialized.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc.GetRequiredService``1">
            <summary>
            Resolves an instance of a specified service type.
            </summary>
            <typeparam name="T">The type of service to resolve.</typeparam>
            <returns>An instance of the specified service, or <see langword="null" />.</returns>
            <exception cref="T:System.InvalidOperationException">
            Throw if the current <see cref="T:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc" /> instance has not been initialized, or if the
            requested service type was not registered in the service provider currently in use.
            </exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc.ConfigureServices(System.IServiceProvider)">
            <summary>
            Initializes the shared <see cref="T:System.IServiceProvider" /> instance.
            </summary>
            <param name="serviceProvider">The input <see cref="T:System.IServiceProvider" /> instance to use.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc.ThrowInvalidOperationExceptionForMissingInitialization">
            <summary>
            Throws an <see cref="T:System.InvalidOperationException" /> when the <see cref="T:System.IServiceProvider" /> property is used before initialization.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc.ThrowInvalidOperationExceptionForUnregisteredType">
            <summary>
            Throws an <see cref="T:System.InvalidOperationException" /> when the <see cref="T:System.IServiceProvider" /> property is missing a type registration.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.DependencyInjection.Ioc.ThrowInvalidOperationExceptionForRepeatedConfiguration">
            <summary>
            Throws an <see cref="T:System.InvalidOperationException" /> when a configuration is attempted more than once.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand">
            <summary>
            A command that mirrors the functionality of <see cref="T:Microsoft.Toolkit.Mvvm.Input.RelayCommand" />, with the addition of
            accepting a <see cref="T:System.Func`1" /> returning a <see cref="T:System.Threading.Tasks.Task" /> as the execute
            action, and providing an <see cref="P:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.ExecutionTask" /> property that notifies changes when
            <see cref="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.ExecuteAsync(System.Object)" /> is invoked and when the returned <see cref="T:System.Threading.Tasks.Task" /> completes.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.CanBeCanceledChangedEventArgs">
            <summary>
            The cached <see cref="T:System.ComponentModel.PropertyChangedEventArgs" /> for <see cref="P:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.CanBeCanceled" />.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.IsCancellationRequestedChangedEventArgs">
            <summary>
            The cached <see cref="T:System.ComponentModel.PropertyChangedEventArgs" /> for <see cref="P:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.IsCancellationRequested" />.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.IsRunningChangedEventArgs">
            <summary>
            The cached <see cref="T:System.ComponentModel.PropertyChangedEventArgs" /> for <see cref="P:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.IsRunning" />.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.execute">
            <summary>
            The <see cref="T:System.Func`1" /> to invoke when <see cref="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.Execute(System.Object)" /> is used.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.cancelableExecute">
            <summary>
            The cancelable <see cref="T:System.Func`2" /> to invoke when <see cref="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.Execute(System.Object)" /> is used.
            </summary>
            <remarks>Only one between this and <see cref="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.execute" /> is not <see langword="null" />.</remarks>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.canExecute">
            <summary>
            The optional action to invoke when <see cref="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.CanExecute(System.Object)" /> is used.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.cancellationTokenSource">
            <summary>
            The <see cref="T:System.Threading.CancellationTokenSource" /> instance to use to cancel <see cref="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.cancelableExecute" />.
            </summary>
            <remarks>This is only used when <see cref="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.cancelableExecute" /> is not <see langword="null" />.</remarks>
        </member>
        <member name="E:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.CanExecuteChanged" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.#ctor(System.Func{System.Threading.Tasks.Task})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand" /> class that can always execute.
            </summary>
            <param name="execute">The execution logic.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.#ctor(System.Func{System.Threading.CancellationToken,System.Threading.Tasks.Task})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand" /> class that can always execute.
            </summary>
            <param name="cancelableExecute">The cancelable execution logic.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.#ctor(System.Func{System.Threading.Tasks.Task},System.Func{System.Boolean})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand" /> class.
            </summary>
            <param name="execute">The execution logic.</param>
            <param name="canExecute">The execution status logic.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.#ctor(System.Func{System.Threading.CancellationToken,System.Threading.Tasks.Task},System.Func{System.Boolean})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand" /> class.
            </summary>
            <param name="cancelableExecute">The cancelable execution logic.</param>
            <param name="canExecute">The execution status logic.</param>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.ExecutionTask">
            <summary>
            Gets the last scheduled <see cref="T:System.Threading.Tasks.Task" />, if available.
            This property notifies a change when the <see cref="T:System.Threading.Tasks.Task" /> completes.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.CanBeCanceled">
            <summary>
            Gets a value indicating whether running operations for this command can be canceled.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.IsCancellationRequested">
            <summary>
            Gets a value indicating whether a cancelation request has been issued for the current operation.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.IsRunning">
            <summary>
            Gets a value indicating whether the command currently has a pending operation being executed.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.NotifyCanExecuteChanged">
            <summary>
            Notifies that the <see cref="M:System.Windows.Input.ICommand.CanExecute(System.Object)" /> property has changed.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.CanExecute(System.Object)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.Execute(System.Object)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.ExecuteAsync(System.Object)">
            <summary>
            Provides a more specific version of <see cref="M:System.Windows.Input.ICommand.Execute(System.Object)" />,
            also returning the <see cref="T:System.Threading.Tasks.Task" /> representing the async operation being executed.
            </summary>
            <param name="parameter">The input parameter.</param>
            <returns>The <see cref="T:System.Threading.Tasks.Task" /> representing the async operation being executed.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand.Cancel">
            <summary>
            Communicates a request for cancelation.
            </summary>
            <remarks>
            If the underlying command is not running, or if it does not support cancelation, this method will perform no action.
            Note that even with a successful cancelation, the completion of the current operation might not be immediate.
            </remarks>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1">
            <summary>
            A generic command that provides a more specific version of <see cref="T:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand" />.
            </summary>
            <typeparam name="T">The type of parameter being passed as input to the callbacks.</typeparam>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.execute">
            <summary>
            The <see cref="T:System.Func`1" /> to invoke when <see cref="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.Execute(`0)" /> is used.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.cancelableExecute">
            <summary>
            The cancelable <see cref="T:System.Func`3" /> to invoke when <see cref="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.Execute(System.Object)" /> is used.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.canExecute">
            <summary>
            The optional action to invoke when <see cref="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.CanExecute(`0)" /> is used.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.cancellationTokenSource">
            <summary>
            The <see cref="T:System.Threading.CancellationTokenSource" /> instance to use to cancel <see cref="F:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.cancelableExecute" />.
            </summary>
        </member>
        <member name="E:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.CanExecuteChanged" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.#ctor(System.Func{`0,System.Threading.Tasks.Task})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1" /> class that can always execute.
            </summary>
            <param name="execute">The execution logic.</param>
            <remarks>See notes in <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.#ctor(System.Action{`0})" />.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.#ctor(System.Func{`0,System.Threading.CancellationToken,System.Threading.Tasks.Task})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1" /> class that can always execute.
            </summary>
            <param name="cancelableExecute">The cancelable execution logic.</param>
            <remarks>See notes in <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.#ctor(System.Action{`0})" />.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.#ctor(System.Func{`0,System.Threading.Tasks.Task},System.Predicate{`0})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1" /> class.
            </summary>
            <param name="execute">The execution logic.</param>
            <param name="canExecute">The execution status logic.</param>
            <remarks>See notes in <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.#ctor(System.Action{`0})" />.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.#ctor(System.Func{`0,System.Threading.CancellationToken,System.Threading.Tasks.Task},System.Predicate{`0})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1" /> class.
            </summary>
            <param name="cancelableExecute">The cancelable execution logic.</param>
            <param name="canExecute">The execution status logic.</param>
            <remarks>See notes in <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.#ctor(System.Action{`0})" />.</remarks>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.ExecutionTask">
            <summary>
            Gets the last scheduled <see cref="T:System.Threading.Tasks.Task" />, if available.
            This property notifies a change when the <see cref="T:System.Threading.Tasks.Task" /> completes.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.CanBeCanceled">
            <summary>
            Gets a value indicating whether running operations for this command can be canceled.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.IsCancellationRequested">
            <summary>
            Gets a value indicating whether a cancelation request has been issued for the current operation.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.IsRunning">
            <summary>
            Gets a value indicating whether the command currently has a pending operation being executed.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.NotifyCanExecuteChanged">
            <summary>
            Notifies that the <see cref="M:System.Windows.Input.ICommand.CanExecute(System.Object)" /> property has changed.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.CanExecute(`0)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.CanExecute(System.Object)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.Execute(`0)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.Execute(System.Object)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.ExecuteAsync(`0)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.ExecuteAsync(System.Object)">
            <summary>
            Provides a more specific version of <see cref="M:System.Windows.Input.ICommand.Execute(System.Object)" />,
            also returning the <see cref="T:System.Threading.Tasks.Task" /> representing the async operation being executed.
            </summary>
            <param name="parameter">The input parameter.</param>
            <returns>The <see cref="T:System.Threading.Tasks.Task" /> representing the async operation being executed.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.AsyncRelayCommand`1.Cancel">
            <summary>
            Communicates a request for cancelation.
            </summary>
            <remarks>
            If the underlying command is not running, or if it does not support cancelation, this method will perform no action.
            Note that even with a successful cancelation, the completion of the current operation might not be immediate.
            </remarks>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Input.IAsyncRelayCommand">
            <summary>
            An interface expanding <see cref="T:Microsoft.Toolkit.Mvvm.Input.IRelayCommand" /> to support asynchronous operations.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Input.IAsyncRelayCommand.ExecutionTask">
            <summary>
            Gets the last scheduled <see cref="T:System.Threading.Tasks.Task" />, if available.
            This property notifies a change when the <see cref="T:System.Threading.Tasks.Task" /> completes.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Input.IAsyncRelayCommand.CanBeCanceled">
            <summary>
            Gets a value indicating whether running operations for this command can be canceled.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Input.IAsyncRelayCommand.IsCancellationRequested">
            <summary>
            Gets a value indicating whether a cancelation request has been issued for the current operation.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Input.IAsyncRelayCommand.IsRunning">
            <summary>
            Gets a value indicating whether the command currently has a pending operation being executed.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.IAsyncRelayCommand.ExecuteAsync(System.Object)">
            <summary>
            Provides a more specific version of <see cref="M:System.Windows.Input.ICommand.Execute(System.Object)" />,
            also returning the <see cref="T:System.Threading.Tasks.Task" /> representing the async operation being executed.
            </summary>
            <param name="parameter">The input parameter.</param>
            <returns>The <see cref="T:System.Threading.Tasks.Task" /> representing the async operation being executed.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.IAsyncRelayCommand.Cancel">
            <summary>
            Communicates a request for cancelation.
            </summary>
            <remarks>
            If the underlying command is not running, or if it does not support cancelation, this method will perform no action.
            Note that even with a successful cancelation, the completion of the current operation might not be immediate.
            </remarks>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Input.IAsyncRelayCommand`1">
            <summary>
            A generic interface representing a more specific version of <see cref="T:Microsoft.Toolkit.Mvvm.Input.IAsyncRelayCommand" />.
            </summary>
            <typeparam name="T">The type used as argument for the interface methods.</typeparam>
            <remarks>This interface is needed to solve the diamond problem with base classes.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.IAsyncRelayCommand`1.ExecuteAsync(`0)">
            <summary>
            Provides a strongly-typed variant of <see cref="M:Microsoft.Toolkit.Mvvm.Input.IAsyncRelayCommand.ExecuteAsync(System.Object)" />.
            </summary>
            <param name="parameter">The input parameter.</param>
            <returns>The <see cref="T:System.Threading.Tasks.Task" /> representing the async operation being executed.</returns>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Input.IRelayCommand">
            <summary>
            An interface expanding <see cref="T:System.Windows.Input.ICommand" /> with the ability to raise
            the <see cref="E:System.Windows.Input.ICommand.CanExecuteChanged" /> event externally.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.IRelayCommand.NotifyCanExecuteChanged">
            <summary>
            Notifies that the <see cref="M:System.Windows.Input.ICommand.CanExecute(System.Object)" /> property has changed.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Input.IRelayCommand`1">
            <summary>
            A generic interface representing a more specific version of <see cref="T:Microsoft.Toolkit.Mvvm.Input.IRelayCommand" />.
            </summary>
            <typeparam name="T">The type used as argument for the interface methods.</typeparam>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.IRelayCommand`1.CanExecute(`0)">
            <summary>
            Provides a strongly-typed variant of <see cref="M:System.Windows.Input.ICommand.CanExecute(System.Object)" />.
            </summary>
            <param name="parameter">The input parameter.</param>
            <returns>Whether or not the current command can be executed.</returns>
            <remarks>Use this overload to avoid boxing, if <typeparamref name="T" /> is a value type.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.IRelayCommand`1.Execute(`0)">
            <summary>
            Provides a strongly-typed variant of <see cref="M:System.Windows.Input.ICommand.Execute(System.Object)" />.
            </summary>
            <param name="parameter">The input parameter.</param>
            <remarks>Use this overload to avoid boxing, if <typeparamref name="T" /> is a value type.</remarks>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Input.RelayCommand">
            <summary>
            A command whose sole purpose is to relay its functionality to other
            objects by invoking delegates. The default return value for the <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand.CanExecute(System.Object)" />
            method is <see langword="true" />. This type does not allow you to accept command parameters
            in the <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand.Execute(System.Object)" /> and <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand.CanExecute(System.Object)" /> callback methods.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.RelayCommand.execute">
            <summary>
            The <see cref="T:System.Action" /> to invoke when <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand.Execute(System.Object)" /> is used.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.RelayCommand.canExecute">
            <summary>
            The optional action to invoke when <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand.CanExecute(System.Object)" /> is used.
            </summary>
        </member>
        <member name="E:Microsoft.Toolkit.Mvvm.Input.RelayCommand.CanExecuteChanged" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand.#ctor(System.Action)">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Input.RelayCommand" /> class that can always execute.
            </summary>
            <param name="execute">The execution logic.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand.#ctor(System.Action,System.Func{System.Boolean})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Input.RelayCommand" /> class.
            </summary>
            <param name="execute">The execution logic.</param>
            <param name="canExecute">The execution status logic.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand.NotifyCanExecuteChanged">
            <summary>
            Notifies that the <see cref="M:System.Windows.Input.ICommand.CanExecute(System.Object)" /> property has changed.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand.CanExecute(System.Object)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand.Execute(System.Object)" />
        <member name="T:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1">
            <summary>
            A generic command whose sole purpose is to relay its functionality to other
            objects by invoking delegates. The default return value for the CanExecute
            method is <see langword="true" />. This class allows you to accept command parameters
            in the <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.Execute(`0)" /> and <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.CanExecute(`0)" /> callback methods.
            </summary>
            <typeparam name="T">The type of parameter being passed as input to the callbacks.</typeparam>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.execute">
            <summary>
            The <see cref="T:System.Action" /> to invoke when <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.Execute(`0)" /> is used.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.canExecute">
            <summary>
            The optional action to invoke when <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.CanExecute(`0)" /> is used.
            </summary>
        </member>
        <member name="E:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.CanExecuteChanged" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.#ctor(System.Action{`0})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1" /> class that can always execute.
            </summary>
            <param name="execute">The execution logic.</param>
            <remarks>
            Due to the fact that the <see cref="T:System.Windows.Input.ICommand" /> interface exposes methods that accept a
            nullable <see cref="T:System.Object" /> parameter, it is recommended that if <typeparamref name="T" /> is a reference type,
            you should always declare it as nullable, and to always perform checks within <paramref name="execute" />.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.#ctor(System.Action{`0},System.Predicate{`0})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1" /> class.
            </summary>
            <param name="execute">The execution logic.</param>
            <param name="canExecute">The execution status logic.</param>
            <remarks>See notes in <see cref="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.#ctor(System.Action{`0})" />.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.NotifyCanExecuteChanged">
            <summary>
            Notifies that the <see cref="M:System.Windows.Input.ICommand.CanExecute(System.Object)" /> property has changed.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.CanExecute(`0)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.CanExecute(System.Object)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.Execute(`0)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Input.RelayCommand`1.Execute(System.Object)" />
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.MessageHandler`2">
            <summary>
            A <see langword="delegate" /> used to represent actions to invoke when a message is received.
            The recipient is given as an input argument to allow message registrations to avoid creating
            closures: if an instance method on a recipient needs to be invoked it is possible to just
            cast the recipient to the right type and then access the local method from that instance.
            </summary>
            <typeparam name="TRecipient">The type of recipient for the message.</typeparam>
            <typeparam name="TMessage">The type of message to receive.</typeparam>
            <param name="recipient">The recipient that is receiving the message.</param>
            <param name="message">The message being received.</param>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger">
            <summary>
            An interface for a type providing the ability to exchange messages between different objects.
            This can be useful to decouple different modules of an application without having to keep strong
            references to types being referenced. It is also possible to send messages to specific channels, uniquely
            identified by a token, and to have different messengers in different sections of an applications.
            In order to use the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> functionalities, first define a message type, like so:
            <code>
            public sealed class LoginCompletedMessage { }
            </code>
            Then, register your a recipient for this message:
            <code>
            Messenger.Default.Register&lt;MyRecipientType, LoginCompletedMessage&gt;(this, (r, m) =&gt;
            {
                // Handle the message here...
            });
            </code>
            The message handler here is a lambda expression taking two parameters: the recipient and the message.
            This is done to avoid the allocations for the closures that would've been generated if the expression
            had captured the current instance. The recipient type parameter is used so that the recipient can be
            directly accessed within the handler without the need to manually perform type casts. This allows the
            code to be less verbose and more reliable, as all the checks are done just at build time. If the handler
            is defined within the same type as the recipient, it is also possible to directly access private members.
            This allows the message handler to be a static method, which enables the C# compiler to perform a number
            of additional memory optimizations (such as caching the delegate, avoiding unnecessary memory allocations).
            Finally, send a message when needed, like so:
            <code>
            Messenger.Default.Send&lt;LoginCompletedMessage&gt;();
            </code>
            Additionally, the method group syntax can also be used to specify the message handler
            to invoke when receiving a message, if a method with the right signature is available
            in the current scope. This is helpful to keep the registration and handling logic separate.
            Following up from the previous example, consider a class having this method:
            <code>
            private static void Receive(MyRecipientType recipient, LoginCompletedMessage message)
            {
                // Handle the message there
            }
            </code>
            The registration can then be performed in a single line like so:
            <code>
            Messenger.Default.Register(this, Receive);
            </code>
            The C# compiler will automatically convert that expression to a <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.MessageHandler`2" /> instance
            compatible with <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Register``2(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,``0,Microsoft.Toolkit.Mvvm.Messaging.MessageHandler{``0,``1})" />.
            This will also work if multiple overloads of that method are available, each handling a different
            message type: the C# compiler will automatically pick the right one for the current message type.
            It is also possible to register message handlers explicitly using the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IRecipient`1" /> interface.
            To do so, the recipient just needs to implement the interface and then call the
            <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.RegisterAll(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,System.Object)" /> extension, which will automatically register
            all the handlers that are declared by the recipient type. Registration for individual handlers is supported as well.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessenger.IsRegistered``2(System.Object,``1)">
            <summary>
            Checks whether or not a given recipient has already been registered for a message.
            </summary>
            <typeparam name="TMessage">The type of message to check for the given recipient.</typeparam>
            <typeparam name="TToken">The type of token to check the channel for.</typeparam>
            <param name="recipient">The target recipient to check the registration for.</param>
            <param name="token">The token used to identify the target channel to check.</param>
            <returns>Whether or not <paramref name="recipient" /> has already been registered for the specified message.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessenger.Register``3(``0,``2,Microsoft.Toolkit.Mvvm.Messaging.MessageHandler{``0,``1})">
            <summary>
            Registers a recipient for a given type of message.
            </summary>
            <typeparam name="TRecipient">The type of recipient for the message.</typeparam>
            <typeparam name="TMessage">The type of message to receive.</typeparam>
            <typeparam name="TToken">The type of token to use to pick the messages to receive.</typeparam>
            <param name="recipient">The recipient that will receive the messages.</param>
            <param name="token">A token used to determine the receiving channel to use.</param>
            <param name="handler">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.MessageHandler`2" /> to invoke when a message is received.</param>
            <exception cref="T:System.InvalidOperationException">Thrown when trying to register the same message twice.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessenger.UnregisterAll(System.Object)">
            <summary>
            Unregisters a recipient from all registered messages.
            </summary>
            <param name="recipient">The recipient to unregister.</param>
            <remarks>
            This method will unregister the target recipient across all channels.
            Use this method as an easy way to lose all references to a target recipient.
            If the recipient has no registered handler, this method does nothing.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessenger.UnregisterAll``1(System.Object,``0)">
            <summary>
            Unregisters a recipient from all messages on a specific channel.
            </summary>
            <typeparam name="TToken">The type of token to identify what channel to unregister from.</typeparam>
            <param name="recipient">The recipient to unregister.</param>
            <param name="token">The token to use to identify which handlers to unregister.</param>
            <remarks>If the recipient has no registered handler, this method does nothing.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessenger.Unregister``2(System.Object,``1)">
            <summary>
            Unregisters a recipient from messages of a given type.
            </summary>
            <typeparam name="TMessage">The type of message to stop receiving.</typeparam>
            <typeparam name="TToken">The type of token to identify what channel to unregister from.</typeparam>
            <param name="recipient">The recipient to unregister.</param>
            <param name="token">The token to use to identify which handlers to unregister.</param>
            <remarks>If the recipient has no registered handler, this method does nothing.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessenger.Send``2(``0,``1)">
            <summary>
            Sends a message of the specified type to all registered recipients.
            </summary>
            <typeparam name="TMessage">The type of message to send.</typeparam>
            <typeparam name="TToken">The type of token to identify what channel to use to send the message.</typeparam>
            <param name="message">The message to send.</param>
            <param name="token">The token indicating what channel to use.</param>
            <returns>The message that was sent (ie. <paramref name="message" />).</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessenger.Cleanup">
            <summary>
            Performs a cleanup on the current messenger.
            Invoking this method does not unregister any of the currently registered
            recipient, and it can be used to perform cleanup operations such as
            trimming the internal data structures of a messenger implementation.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessenger.Reset">
            <summary>
            Resets the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance and unregisters all the existing recipients.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions">
            <summary>
            Extensions for the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> type.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.IsRegistered``1(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,System.Object)">
            <summary>
            Checks whether or not a given recipient has already been registered for a message.
            </summary>
            <typeparam name="TMessage">The type of message to check for the given recipient.</typeparam>
            <param name="messenger">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance to use to check the registration.</param>
            <param name="recipient">The target recipient to check the registration for.</param>
            <returns>Whether or not <paramref name="recipient" /> has already been registered for the specified message.</returns>
            <remarks>This method will use the default channel to check for the requested registration.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.RegisterAll(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,System.Object)">
            <summary>
            Registers all declared message handlers for a given recipient, using the default channel.
            </summary>
            <param name="messenger">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance to use to register the recipient.</param>
            <param name="recipient">The recipient that will receive the messages.</param>
            <remarks>See notes for <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.RegisterAll``1(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,System.Object,``0)" /> for more info.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.RegisterAll``1(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,System.Object,``0)">
            <summary>
            Registers all declared message handlers for a given recipient.
            </summary>
            <typeparam name="TToken">The type of token to identify what channel to use to receive messages.</typeparam>
            <param name="messenger">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance to use to register the recipient.</param>
            <param name="recipient">The recipient that will receive the messages.</param>
            <param name="token">The token indicating what channel to use.</param>
            <remarks>
            This method will register all messages corresponding to the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IRecipient`1" /> interfaces
            being implemented by <paramref name="recipient" />. If none are present, this method will do nothing.
            Note that unlike all other extensions, this method will use reflection to find the handlers to register.
            Once the registration is complete though, the performance will be exactly the same as with handlers
            registered directly through any of the other generic extensions for the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> interface.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Register``1(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,Microsoft.Toolkit.Mvvm.Messaging.IRecipient{``0})">
            <summary>
            Registers a recipient for a given type of message.
            </summary>
            <typeparam name="TMessage">The type of message to receive.</typeparam>
            <param name="messenger">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance to use to register the recipient.</param>
            <param name="recipient">The recipient that will receive the messages.</param>
            <exception cref="T:System.InvalidOperationException">Thrown when trying to register the same message twice.</exception>
            <remarks>This method will use the default channel to perform the requested registration.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Register``2(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,Microsoft.Toolkit.Mvvm.Messaging.IRecipient{``0},``1)">
            <summary>
            Registers a recipient for a given type of message.
            </summary>
            <typeparam name="TMessage">The type of message to receive.</typeparam>
            <typeparam name="TToken">The type of token to identify what channel to use to receive messages.</typeparam>
            <param name="messenger">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance to use to register the recipient.</param>
            <param name="recipient">The recipient that will receive the messages.</param>
            <param name="token">The token indicating what channel to use.</param>
            <exception cref="T:System.InvalidOperationException">Thrown when trying to register the same message twice.</exception>
            <remarks>This method will use the default channel to perform the requested registration.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Register``1(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,System.Object,Microsoft.Toolkit.Mvvm.Messaging.MessageHandler{System.Object,``0})">
            <summary>
            Registers a recipient for a given type of message.
            </summary>
            <typeparam name="TMessage">The type of message to receive.</typeparam>
            <param name="messenger">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance to use to register the recipient.</param>
            <param name="recipient">The recipient that will receive the messages.</param>
            <param name="handler">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.MessageHandler`2" /> to invoke when a message is received.</param>
            <exception cref="T:System.InvalidOperationException">Thrown when trying to register the same message twice.</exception>
            <remarks>This method will use the default channel to perform the requested registration.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Register``2(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,``0,Microsoft.Toolkit.Mvvm.Messaging.MessageHandler{``0,``1})">
            <summary>
            Registers a recipient for a given type of message.
            </summary>
            <typeparam name="TRecipient">The type of recipient for the message.</typeparam>
            <typeparam name="TMessage">The type of message to receive.</typeparam>
            <param name="messenger">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance to use to register the recipient.</param>
            <param name="recipient">The recipient that will receive the messages.</param>
            <param name="handler">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.MessageHandler`2" /> to invoke when a message is received.</param>
            <exception cref="T:System.InvalidOperationException">Thrown when trying to register the same message twice.</exception>
            <remarks>This method will use the default channel to perform the requested registration.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Register``2(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,System.Object,``1,Microsoft.Toolkit.Mvvm.Messaging.MessageHandler{System.Object,``0})">
            <summary>
            Registers a recipient for a given type of message.
            </summary>
            <typeparam name="TMessage">The type of message to receive.</typeparam>
            <typeparam name="TToken">The type of token to use to pick the messages to receive.</typeparam>
            <param name="messenger">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance to use to register the recipient.</param>
            <param name="recipient">The recipient that will receive the messages.</param>
            <param name="token">A token used to determine the receiving channel to use.</param>
            <param name="handler">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.MessageHandler`2" /> to invoke when a message is received.</param>
            <exception cref="T:System.InvalidOperationException">Thrown when trying to register the same message twice.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Unregister``1(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,System.Object)">
            <summary>
            Unregisters a recipient from messages of a given type.
            </summary>
            <typeparam name="TMessage">The type of message to stop receiving.</typeparam>
            <param name="messenger">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance to use to unregister the recipient.</param>
            <param name="recipient">The recipient to unregister.</param>
            <remarks>
            This method will unregister the target recipient only from the default channel.
            If the recipient has no registered handler, this method does nothing.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Send``1(Microsoft.Toolkit.Mvvm.Messaging.IMessenger)">
            <summary>
            Sends a message of the specified type to all registered recipients.
            </summary>
            <typeparam name="TMessage">The type of message to send.</typeparam>
            <param name="messenger">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance to use to send the message.</param>
            <returns>The message that has been sent.</returns>
            <remarks>
            This method is a shorthand for <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Send``1(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,``0)" /> when the
            message type exposes a parameterless constructor: it will automatically create
            a new <typeparamref name="TMessage" /> instance and send that to its recipients.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Send``1(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,``0)">
            <summary>
            Sends a message of the specified type to all registered recipients.
            </summary>
            <typeparam name="TMessage">The type of message to send.</typeparam>
            <param name="messenger">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance to use to send the message.</param>
            <param name="message">The message to send.</param>
            <returns>The message that was sent (ie. <paramref name="message" />).</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Send``2(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,``1)">
            <summary>
            Sends a message of the specified type to all registered recipients.
            </summary>
            <typeparam name="TMessage">The type of message to send.</typeparam>
            <typeparam name="TToken">The type of token to identify what channel to use to send the message.</typeparam>
            <param name="messenger">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance to use to send the message.</param>
            <param name="token">The token indicating what channel to use.</param>
            <returns>The message that has been sen.</returns>
            <remarks>
            This method will automatically create a new <typeparamref name="TMessage" /> instance
            just like <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Send``1(Microsoft.Toolkit.Mvvm.Messaging.IMessenger)" />, and then send it to the right recipients.
            </remarks>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.MethodInfos">
            <summary>
            A class that acts as a container to load the <see cref="T:System.Reflection.MethodInfo" /> instance linked to
            the <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Register``2(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,Microsoft.Toolkit.Mvvm.Messaging.IRecipient{``0},``1)" /> method.
            This class is needed to avoid forcing the initialization code in the static constructor to run as soon as
            the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions" /> type is referenced, even if that is done just to use methods
            that do not actually require this <see cref="T:System.Reflection.MethodInfo" /> instance to be available.
            We're effectively using this type to leverage the lazy loading of static constructors done by the runtime.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.MethodInfos.RegisterIRecipient">
            <summary>
            The <see cref="T:System.Reflection.MethodInfo" /> instance associated with <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.Register``2(Microsoft.Toolkit.Mvvm.Messaging.IMessenger,Microsoft.Toolkit.Mvvm.Messaging.IRecipient{``0},``1)" />.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.DiscoveredRecipients`1">
            <summary>
            A class that acts as a static container to associate a <see cref="T:System.Runtime.CompilerServices.ConditionalWeakTable`2" /> instance to each
            <typeparamref name="TToken" /> type in use. This is done because we can only use a single type as key, but we need to track
            associations of each recipient type also across different communication channels, each identified by a token.
            Since the token is actually a compile-time parameter, we can use a wrapping class to let the runtime handle a different
            instance for each generic type instantiation. This lets us only worry about the recipient type being inspected.
            </summary>
            <typeparam name="TToken">The token indicating what channel to use.</typeparam>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.IMessengerExtensions.DiscoveredRecipients`1.RegistrationMethods">
            <summary>
            The <see cref="T:System.Runtime.CompilerServices.ConditionalWeakTable`2" /> instance used to track the preloaded registration actions for each recipient.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.Internals.Type2">
            <summary>
            A simple type representing an immutable pair of types.
            </summary>
            <remarks>
            This type replaces a simple <see cref="T:System.ValueTuple`2" /> as it's faster in its
            <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.Internals.Type2.GetHashCode" /> and <see cref="M:System.IEquatable`1.Equals(`0)" /> methods, and because
            unlike a value tuple it exposes its fields as immutable. Additionally, the
            <see cref="F:Microsoft.Toolkit.Mvvm.Messaging.Internals.Type2.TMessage" /> and <see cref="F:Microsoft.Toolkit.Mvvm.Messaging.Internals.Type2.TToken" /> fields provide additional clarity reading
            the code compared to <see cref="F:System.ValueTuple`2.Item1" /> and <see cref="F:System.ValueTuple`2.Item2" />.
            </remarks>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.Internals.Type2.TMessage">
            <summary>
            The type of registered message.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.Internals.Type2.TToken">
            <summary>
            The type of registration token.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Internals.Type2.#ctor(System.Type,System.Type)">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.Internals.Type2" /> struct.
            </summary>
            <param name="tMessage">The type of registered message.</param>
            <param name="tToken">The type of registration token.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Internals.Type2.Equals(Microsoft.Toolkit.Mvvm.Messaging.Internals.Type2)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Internals.Type2.Equals(System.Object)">
            <summary>Indicates whether this instance and a specified object are equal.</summary>
            <returns>true if <paramref name="obj" /> and this instance are the same type and represent the same value; otherwise, false. </returns>
            <param name="obj">The object to compare with the current instance. </param>
            <filterpriority>2</filterpriority>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Internals.Type2.GetHashCode">
            <summary>Returns the hash code for this instance.</summary>
            <returns>A 32-bit signed integer that is the hash code for this instance.</returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.Internals.Unit">
            <summary>
            An empty type representing a generic token with no specific value.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Internals.Unit.Equals(Microsoft.Toolkit.Mvvm.Messaging.Internals.Unit)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Internals.Unit.Equals(System.Object)">
            <summary>Indicates whether this instance and a specified object are equal.</summary>
            <returns>true if <paramref name="obj" /> and this instance are the same type and represent the same value; otherwise, false. </returns>
            <param name="obj">The object to compare with the current instance. </param>
            <filterpriority>2</filterpriority>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Internals.Unit.GetHashCode">
            <summary>Returns the hash code for this instance.</summary>
            <returns>A 32-bit signed integer that is the hash code for this instance.</returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.IRecipient`1">
            <summary>
            An interface for a recipient that declares a registration for a specific message type.
            </summary>
            <typeparam name="TMessage">The type of message to receive.</typeparam>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.IRecipient`1.Receive(`0)">
            <summary>
            Receives a given <typeparamref name="TMessage" /> message instance.
            </summary>
            <param name="message">The message being received.</param>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncCollectionRequestMessage`1">
            <summary>
            A <see langword="class" /> for request messages that can receive multiple replies, which can either be used directly or through derived classes.
            </summary>
            <typeparam name="T">The type of request to make.</typeparam>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncCollectionRequestMessage`1.responses">
            <summary>
            The collection of received replies. We accept both <see cref="T:System.Threading.Tasks.Task`1" /> instance, representing already running
            operations that can be executed in parallel, or <see cref="T:System.Func`2" /> instances, which can be used so that multiple
            asynchronous operations are only started sequentially from <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncCollectionRequestMessage`1.GetAsyncEnumerator(System.Threading.CancellationToken)" /> and do not overlap in time.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncCollectionRequestMessage`1.cancellationTokenSource">
            <summary>
            The <see cref="T:System.Threading.CancellationTokenSource" /> instance used to link the token passed to
            <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncCollectionRequestMessage`1.GetAsyncEnumerator(System.Threading.CancellationToken)" /> and the one passed to all subscribers to the message.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncCollectionRequestMessage`1.CancellationToken">
            <summary>
            Gets the <see cref="T:System.Threading.CancellationToken" /> instance that will be linked to the
            one used to asynchronously enumerate the received responses. This can be used to cancel asynchronous
            replies that are still being processed, if no new items are needed from this request message.
            Consider the following example, where we define a message to retrieve the currently opened documents:
            <code>
            public class OpenDocumentsRequestMessage : AsyncCollectionRequestMessage&lt;XmlDocument&gt; { }
            </code>
            We can then request and enumerate the results like so:
            <code>
            await foreach (var document in Messenger.Default.Send&lt;OpenDocumentsRequestMessage&gt;())
            {
                // Process each document here...
            }
            </code>
            If we also want to control the cancellation of the token passed to each subscriber to the message,
            we can do so by passing a token we control to the returned message before starting the enumeration
            (<see cref="M:System.Threading.Tasks.TaskAsyncEnumerableExtensions.WithCancellation``1(System.Collections.Generic.IAsyncEnumerable{``0},System.Threading.CancellationToken)" />).
            The previous snippet with this additional change looks as follows:
            <code>
            await foreach (var document in Messenger.Default.Send&lt;OpenDocumentsRequestMessage&gt;().WithCancellation(cts.Token))
            {
                // Process each document here...
            }
            </code>
            When no more new items are needed (or for any other reason depending on the situation), the token
            passed to the enumerator can be canceled (by calling <see cref="M:System.Threading.CancellationTokenSource.Cancel" />),
            and that will also notify the remaining tasks in the request message. The token exposed by the message
            itself will automatically be linked and canceled with the one passed to the enumerator.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncCollectionRequestMessage`1.Reply(`0)">
            <summary>
            Replies to the current request message.
            </summary>
            <param name="response">The response to use to reply to the request message.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncCollectionRequestMessage`1.Reply(System.Threading.Tasks.Task{`0})">
            <summary>
            Replies to the current request message.
            </summary>
            <param name="response">The response to use to reply to the request message.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncCollectionRequestMessage`1.Reply(System.Func{System.Threading.CancellationToken,System.Threading.Tasks.Task{`0}})">
            <summary>
            Replies to the current request message.
            </summary>
            <param name="response">The response to use to reply to the request message.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncCollectionRequestMessage`1.GetResponsesAsync(System.Threading.CancellationToken)">
            <summary>
            Gets the collection of received response items.
            </summary>
            <param name="cancellationToken">A <see cref="T:System.Threading.CancellationToken" /> value to stop the operation.</param>
            <returns>The collection of received response items.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncCollectionRequestMessage`1.GetAsyncEnumerator(System.Threading.CancellationToken)" />
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncRequestMessage`1">
            <summary>
            A <see langword="class" /> for async request messages, which can either be used directly or through derived classes.
            </summary>
            <typeparam name="T">The type of request to make.</typeparam>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncRequestMessage`1.Response">
            <summary>
            Gets the message response.
            </summary>
            <exception cref="T:System.InvalidOperationException">Thrown when <see cref="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncRequestMessage`1.HasReceivedResponse" /> is <see langword="false" />.</exception>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncRequestMessage`1.HasReceivedResponse">
            <summary>
            Gets a value indicating whether a response has already been assigned to this instance.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncRequestMessage`1.Reply(`0)">
            <summary>
            Replies to the current request message.
            </summary>
            <param name="response">The response to use to reply to the request message.</param>
            <exception cref="T:System.InvalidOperationException">Thrown if <see cref="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncRequestMessage`1.Response" /> has already been set.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncRequestMessage`1.Reply(System.Threading.Tasks.Task{`0})">
            <summary>
            Replies to the current request message.
            </summary>
            <param name="response">The response to use to reply to the request message.</param>
            <exception cref="T:System.InvalidOperationException">Thrown if <see cref="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncRequestMessage`1.Response" /> has already been set.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncRequestMessage`1.GetAwaiter" />
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncRequestMessage`1.ThrowInvalidOperationExceptionForNoResponseReceived">
            <summary>
            Throws an <see cref="T:System.InvalidOperationException" /> when a response is not available.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncRequestMessage`1.ThrowInvalidOperationExceptionForDuplicateReply">
            <summary>
            Throws an <see cref="T:System.InvalidOperationException" /> when <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncRequestMessage`1.Reply(`0)" /> or <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.AsyncRequestMessage`1.Reply(System.Threading.Tasks.Task{`0})" /> are called twice.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.Messages.CollectionRequestMessage`1">
            <summary>
            A <see langword="class" /> for request messages that can receive multiple replies, which can either be used directly or through derived classes.
            </summary>
            <typeparam name="T">The type of request to make.</typeparam>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.CollectionRequestMessage`1.Responses">
            <summary>
            Gets the message responses.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.CollectionRequestMessage`1.Reply(`0)">
            <summary>
            Replies to the current request message.
            </summary>
            <param name="response">The response to use to reply to the request message.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.CollectionRequestMessage`1.GetEnumerator">
            <summary>Returns an enumerator that iterates through a collection.</summary>
            <returns>An <see cref="T:System.Collections.IEnumerator" /> object that can be used to iterate through the collection.</returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.CollectionRequestMessage`1.System#Collections#IEnumerable#GetEnumerator" />
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.Messages.PropertyChangedMessage`1">
            <summary>
            A message used to broadcast property changes in observable objects.
            </summary>
            <typeparam name="T">The type of the property to broadcast the change for.</typeparam>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.PropertyChangedMessage`1.#ctor(System.Object,System.String,`0,`0)">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.Messages.PropertyChangedMessage`1" /> class.
            </summary>
            <param name="sender">The original sender of the broadcast message.</param>
            <param name="propertyName">The name of the property that changed.</param>
            <param name="oldValue">The value that the property had before the change.</param>
            <param name="newValue">The value that the property has after the change.</param>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.PropertyChangedMessage`1.Sender">
            <summary>
            Gets the original sender of the broadcast message.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.PropertyChangedMessage`1.PropertyName">
            <summary>
            Gets the name of the property that changed.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.PropertyChangedMessage`1.OldValue">
            <summary>
            Gets the value that the property had before the change.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.PropertyChangedMessage`1.NewValue">
            <summary>
            Gets the value that the property has after the change.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage`1">
            <summary>
            A <see langword="class" /> for request messages, which can either be used directly or through derived classes.
            </summary>
            <typeparam name="T">The type of request to make.</typeparam>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage`1.Response">
            <summary>
            Gets the message response.
            </summary>
            <exception cref="T:System.InvalidOperationException">Thrown when <see cref="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage`1.HasReceivedResponse" /> is <see langword="false" />.</exception>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage`1.HasReceivedResponse">
            <summary>
            Gets a value indicating whether a response has already been assigned to this instance.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage`1.Reply(`0)">
            <summary>
            Replies to the current request message.
            </summary>
            <param name="response">The response to use to reply to the request message.</param>
            <exception cref="T:System.InvalidOperationException">Thrown if <see cref="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage`1.Response" /> has already been set.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage`1.op_Implicit(Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage{`0})~`0">
            <summary>
            Implicitly gets the response from a given <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage`1" /> instance.
            </summary>
            <param name="message">The input <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage`1" /> instance.</param>
            <exception cref="T:System.InvalidOperationException">Thrown when <see cref="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage`1.HasReceivedResponse" /> is <see langword="false" />.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage`1.ThrowInvalidOperationExceptionForNoResponseReceived">
            <summary>
            Throws an <see cref="T:System.InvalidOperationException" /> when a response is not available.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage`1.ThrowInvalidOperationExceptionForDuplicateReply">
            <summary>
            Throws an <see cref="T:System.InvalidOperationException" /> when <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.RequestMessage`1.Reply(`0)" /> is called twice.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.Messages.ValueChangedMessage`1">
            <summary>
            A base message that signals whenever a specific value has changed.
            </summary>
            <typeparam name="T">The type of value that has changed.</typeparam>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.Messages.ValueChangedMessage`1.#ctor(`0)">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.Messages.ValueChangedMessage`1" /> class.
            </summary>
            <param name="value">The value that has changed.</param>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.Messages.ValueChangedMessage`1.Value">
            <summary>
            Gets the value that has changed.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger">
            <summary>
            A class providing a reference implementation for the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> interface.
            </summary>
            <remarks>
            This <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> implementation uses strong references to track the registered
            recipients, so it is necessary to manually unregister them when they're no longer needed.
            </remarks>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.recipientsMap">
            <summary>
            The collection of currently registered recipients, with a link to their linked message receivers.
            </summary>
            <remarks>
            This collection is used to allow reflection-free access to all the existing
            registered recipients from <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.UnregisterAll(System.Object)" /> and other methods in this type,
            so that all the existing handlers can be removed without having to dynamically create
            the generic types for the containers of the various dictionaries mapping the handlers.
            </remarks>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.typesMap">
            <summary>
            The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Mapping`2" /> instance for types combination.
            </summary>
            <remarks>
            The values are just of type <see cref="T:Microsoft.Collections.Extensions.IDictionarySlim`1" /> as we don't know the type parameters in advance.
            Each method relies on <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.GetOrAddMapping``2" /> to get the type-safe instance
            of the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Mapping`2" /> class for each pair of generic arguments in use.
            </remarks>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Default">
            <summary>
            Gets the default <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger" /> instance.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.IsRegistered``2(System.Object,``1)">
            <summary>
            Checks whether or not a given recipient has already been registered for a message.
            </summary>
            <typeparam name="TMessage">The type of message to check for the given recipient.</typeparam>
            <typeparam name="TToken">The type of token to check the channel for.</typeparam>
            <param name="recipient">The target recipient to check the registration for.</param>
            <param name="token">The token used to identify the target channel to check.</param>
            <returns>Whether or not <paramref name="recipient" /> has already been registered for the specified message.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Register``3(``0,``2,Microsoft.Toolkit.Mvvm.Messaging.MessageHandler{``0,``1})">
            <summary>
            Registers a recipient for a given type of message.
            </summary>
            <typeparam name="TRecipient">The type of recipient for the message.</typeparam>
            <typeparam name="TMessage">The type of message to receive.</typeparam>
            <typeparam name="TToken">The type of token to use to pick the messages to receive.</typeparam>
            <param name="recipient">The recipient that will receive the messages.</param>
            <param name="token">A token used to determine the receiving channel to use.</param>
            <param name="handler">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.MessageHandler`2" /> to invoke when a message is received.</param>
            <exception cref="T:System.InvalidOperationException">Thrown when trying to register the same message twice.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.UnregisterAll(System.Object)">
            <summary>
            Unregisters a recipient from all registered messages.
            </summary>
            <param name="recipient">The recipient to unregister.</param>
            <remarks>
            This method will unregister the target recipient across all channels.
            Use this method as an easy way to lose all references to a target recipient.
            If the recipient has no registered handler, this method does nothing.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.UnregisterAll``1(System.Object,``0)">
            <summary>
            Unregisters a recipient from all messages on a specific channel.
            </summary>
            <typeparam name="TToken">The type of token to identify what channel to unregister from.</typeparam>
            <param name="recipient">The recipient to unregister.</param>
            <param name="token">The token to use to identify which handlers to unregister.</param>
            <remarks>If the recipient has no registered handler, this method does nothing.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Unregister``2(System.Object,``1)">
            <summary>
            Unregisters a recipient from messages of a given type.
            </summary>
            <typeparam name="TMessage">The type of message to stop receiving.</typeparam>
            <typeparam name="TToken">The type of token to identify what channel to unregister from.</typeparam>
            <param name="recipient">The recipient to unregister.</param>
            <param name="token">The token to use to identify which handlers to unregister.</param>
            <remarks>If the recipient has no registered handler, this method does nothing.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Send``2(``0,``1)">
            <summary>
            Sends a message of the specified type to all registered recipients.
            </summary>
            <typeparam name="TMessage">The type of message to send.</typeparam>
            <typeparam name="TToken">The type of token to identify what channel to use to send the message.</typeparam>
            <param name="message">The message to send.</param>
            <param name="token">The token indicating what channel to use.</param>
            <returns>The message that was sent (ie. <paramref name="message" />).</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Microsoft#Toolkit#Mvvm#Messaging#IMessenger#Cleanup" />
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Reset">
            <summary>
            Resets the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance and unregisters all the existing recipients.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.TryGetMapping``2(Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Mapping{``0,``1}@)">
            <summary>
            Tries to get the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Mapping`2" /> instance of currently registered recipients
            for the combination of types <typeparamref name="TMessage" /> and <typeparamref name="TToken" />.
            </summary>
            <typeparam name="TMessage">The type of message to send.</typeparam>
            <typeparam name="TToken">The type of token to identify what channel to use to send the message.</typeparam>
            <param name="mapping">The resulting <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Mapping`2" /> instance, if found.</param>
            <returns>Whether or not the required <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Mapping`2" /> instance was found.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.GetOrAddMapping``2">
            <summary>
            Gets the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Mapping`2" /> instance of currently registered recipients
            for the combination of types <typeparamref name="TMessage" /> and <typeparamref name="TToken" />.
            </summary>
            <typeparam name="TMessage">The type of message to send.</typeparam>
            <typeparam name="TToken">The type of token to identify what channel to use to send the message.</typeparam>
            <returns>A <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Mapping`2" /> instance with the requested type arguments.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.ThrowInvalidOperationExceptionForDuplicateRegistration">
            <summary>
            Throws an <see cref="T:System.InvalidOperationException" /> when trying to add a duplicate handler.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Mapping`2">
            <summary>
            A mapping type representing a link to recipients and their view of handlers per communication channel.
            </summary>
            <typeparam name="TMessage">The type of message to receive.</typeparam>
            <typeparam name="TToken">The type of token to use to pick the messages to receive.</typeparam>
            <remarks>
            This type is defined for simplicity and as a workaround for the lack of support for using type aliases
            over open generic types in C# (using type aliases can only be used for concrete, closed types).
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Mapping`2.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Mapping`2" /> class.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Mapping`2.TypeArguments" />
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.IMapping">
            <summary>
            An interface for the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Mapping`2" /> type which allows to retrieve the type
            arguments from a given generic instance without having any prior knowledge about those arguments.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.IMapping.TypeArguments">
            <summary>
            Gets the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.Internals.Type2" /> instance representing the current type arguments.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Recipient">
            <summary>
            A simple type representing a recipient.
            </summary>
            <remarks>
            This type is used to enable fast indexing in each mapping dictionary,
            since it acts as an external override for the <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Recipient.GetHashCode" /> and
            <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Recipient.Equals(System.Object)" /> methods for arbitrary objects, removing both
            the virtual call and preventing instances overriding those methods in this context.
            Using this type guarantees that all the equality operations are always only done
            based on reference equality for each registered recipient, regardless of its type.
            </remarks>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Recipient.Target">
            <summary>
            The registered recipient.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Recipient.#ctor(System.Object)">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Recipient" /> struct.
            </summary>
            <param name="target">The target recipient instance.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Recipient.Equals(Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Recipient)" />
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Recipient.Equals(System.Object)">
            <summary>Indicates whether this instance and a specified object are equal.</summary>
            <returns>true if <paramref name="obj" /> and this instance are the same type and represent the same value; otherwise, false. </returns>
            <param name="obj">The object to compare with the current instance. </param>
            <filterpriority>2</filterpriority>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger.Recipient.GetHashCode">
            <summary>Returns the hash code for this instance.</summary>
            <returns>A 32-bit signed integer that is the hash code for this instance.</returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger">
            <summary>
            A class providing a reference implementation for the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> interface.
            </summary>
            <remarks>
            This <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> implementation uses weak references to track the registered
            recipients, so it is not necessary to manually unregister them when they're no longer needed.
            </remarks>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.recipientsMap">
            <summary>
            The map of currently registered recipients for all message types.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.Default">
            <summary>
            Gets the default <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger" /> instance.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.IsRegistered``2(System.Object,``1)">
            <summary>
            Checks whether or not a given recipient has already been registered for a message.
            </summary>
            <typeparam name="TMessage">The type of message to check for the given recipient.</typeparam>
            <typeparam name="TToken">The type of token to check the channel for.</typeparam>
            <param name="recipient">The target recipient to check the registration for.</param>
            <param name="token">The token used to identify the target channel to check.</param>
            <returns>Whether or not <paramref name="recipient" /> has already been registered for the specified message.</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.Register``3(``0,``2,Microsoft.Toolkit.Mvvm.Messaging.MessageHandler{``0,``1})">
            <summary>
            Registers a recipient for a given type of message.
            </summary>
            <typeparam name="TRecipient">The type of recipient for the message.</typeparam>
            <typeparam name="TMessage">The type of message to receive.</typeparam>
            <typeparam name="TToken">The type of token to use to pick the messages to receive.</typeparam>
            <param name="recipient">The recipient that will receive the messages.</param>
            <param name="token">A token used to determine the receiving channel to use.</param>
            <param name="handler">The <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.MessageHandler`2" /> to invoke when a message is received.</param>
            <exception cref="T:System.InvalidOperationException">Thrown when trying to register the same message twice.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.UnregisterAll(System.Object)">
            <summary>
            Unregisters a recipient from all registered messages.
            </summary>
            <param name="recipient">The recipient to unregister.</param>
            <remarks>
            This method will unregister the target recipient across all channels.
            Use this method as an easy way to lose all references to a target recipient.
            If the recipient has no registered handler, this method does nothing.
            </remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.UnregisterAll``1(System.Object,``0)">
            <summary>
            Unregisters a recipient from all messages on a specific channel.
            </summary>
            <typeparam name="TToken">The type of token to identify what channel to unregister from.</typeparam>
            <param name="recipient">The recipient to unregister.</param>
            <param name="token">The token to use to identify which handlers to unregister.</param>
            <remarks>If the recipient has no registered handler, this method does nothing.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.Unregister``2(System.Object,``1)">
            <summary>
            Unregisters a recipient from messages of a given type.
            </summary>
            <typeparam name="TMessage">The type of message to stop receiving.</typeparam>
            <typeparam name="TToken">The type of token to identify what channel to unregister from.</typeparam>
            <param name="recipient">The recipient to unregister.</param>
            <param name="token">The token to use to identify which handlers to unregister.</param>
            <remarks>If the recipient has no registered handler, this method does nothing.</remarks>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.Send``2(``0,``1)">
            <summary>
            Sends a message of the specified type to all registered recipients.
            </summary>
            <typeparam name="TMessage">The type of message to send.</typeparam>
            <typeparam name="TToken">The type of token to identify what channel to use to send the message.</typeparam>
            <param name="message">The message to send.</param>
            <param name="token">The token indicating what channel to use.</param>
            <returns>The message that was sent (ie. <paramref name="message" />).</returns>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.Cleanup">
            <summary>
            Performs a cleanup on the current messenger.
            Invoking this method does not unregister any of the currently registered
            recipient, and it can be used to perform cleanup operations such as
            trimming the internal data structures of a messenger implementation.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.Reset">
            <summary>
            Resets the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.IMessenger" /> instance and unregisters all the existing recipients.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ThrowInvalidOperationExceptionForDuplicateRegistration">
            <summary>
            Throws an <see cref="T:System.InvalidOperationException" /> when trying to add a duplicate handler.
            </summary>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2">
            <summary>
            A wrapper for <see cref="T:System.Runtime.CompilerServices.ConditionalWeakTable`2" />
            that backports the enumerable support to .NET Standard 2.0 through an auxiliary list.
            </summary>
            <typeparam name="TKey">Tke key of items to store in the table.</typeparam>
            <typeparam name="TValue">The values to store in the table.</typeparam>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.table">
            <summary>
            The underlying <see cref="T:System.Runtime.CompilerServices.ConditionalWeakTable`2" /> instance.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.keys">
            <summary>
            A supporting linked list to store keys in <see cref="F:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.table" />. This is needed to expose
            the ability to enumerate existing keys when there is no support for that in the BCL.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.TryGetValue(`0,`1@)">
            <summary>Gets the value of the specified key.</summary>
            <returns>true if <paramref name="key" /> is found; otherwise, false.</returns>
            <param name="key">The key that represents an object with an attached property.</param>
            <param name="value">When this method returns, contains the attached property value. If <paramref name="key" /> is not found, <paramref name="value" /> contains the default value.</param>
            <exception cref="T:System.ArgumentNullException">
                <paramref name="key" /> is null.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.GetValue(`0,System.Runtime.CompilerServices.ConditionalWeakTable{`0,`1}.CreateValueCallback)">
            <summary>Atomically searches for a specified key in the table and returns the corresponding value. If the key does not exist in the table, the method invokes a callback method to create a value that is bound to the specified key.</summary>
            <returns>The value attached to <paramref name="key" />, if <paramref name="key" /> already exists in the table; otherwise, the new value returned by the <paramref name="createValueCallback" /> delegate.</returns>
            <param name="key">The key to search for. <paramref name="key" /> represents the object to which the property is attached.</param>
            <param name="createValueCallback">A delegate to a method that can create a value for the given <paramref name="key" />. It has a single parameter of type <paramref name="TKey" />, and returns a value of type <paramref name="TValue" />.</param>
            <exception cref="T:System.ArgumentNullException">
                <paramref name="key" /> or <paramref name="createValueCallback" /> is null.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.Remove(`0)">
            <summary>Removes a key and its value from the table.</summary>
            <returns>true if the key is found and removed; otherwise, false.</returns>
            <param name="key">The key to remove. </param>
            <exception cref="T:System.ArgumentNullException">
                <paramref name="key" /> is null.</exception>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.GetEnumerator">
            <summary>Returns an enumerator that iterates through the collection.</summary>
            <returns>An enumerator that can be used to iterate through the collection.</returns>
            <filterpriority>1</filterpriority>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.Enumerator">
            <summary>
            A custom enumerator that traverses items in a <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2" /> instance.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.Enumerator.owner">
            <summary>
            The owner <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2" /> instance for the enumerator.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.Enumerator.node">
            <summary>
            The current <see cref="T:System.Collections.Generic.LinkedListNode`1" />, if any.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.Enumerator.current">
            <summary>
            The current <see cref="T:System.Collections.Generic.KeyValuePair`2" /> to return.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.Enumerator.isFirstMoveNextPending">
            <summary>
            Indicates whether or not <see cref="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.Enumerator.MoveNext" /> has been called at least once.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.Enumerator.#ctor(Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable{`0,`1})">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.Enumerator" /> struct.
            </summary>
            <param name="owner">The owner <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2" /> instance for the enumerator.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.Enumerator.MoveNext">
            <summary>Advances the enumerator to the next element of the collection.</summary>
            <returns>true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.</returns>
            <exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created. </exception>
            <filterpriority>2</filterpriority>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.Enumerator.Current">
            <summary>Gets the current element in the collection.</summary>
            <returns>The current element in the collection.</returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ConditionalWeakTable`2.Enumerator.Current">
            <summary>Advances the enumerator to the next element of the collection.</summary>
            <returns>true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.</returns>
            <exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created. </exception>
            <filterpriority>2</filterpriority>
        </member>
        <member name="T:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ArrayPoolBufferWriter`1">
            <summary>
            A simple buffer writer implementation using pooled arrays.
            </summary>
            <typeparam name="T">The type of items to store in the list.</typeparam>
            <remarks>
            This type is a <see langword="ref" /><see langword="struct" /> to avoid the object allocation and to
            enable the pattern-based <see cref="T:System.IDisposable" /> support. We aren't worried with consumers not
            using this type correctly since it's private and only accessible within the parent type.
            </remarks>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ArrayPoolBufferWriter`1.DefaultInitialBufferSize">
            <summary>
            The default buffer size to use to expand empty arrays.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ArrayPoolBufferWriter`1.array">
            <summary>
            The underlying <typeparamref name="T" /> array.
            </summary>
        </member>
        <member name="F:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ArrayPoolBufferWriter`1.index">
            <summary>
            The starting offset within <see cref="F:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ArrayPoolBufferWriter`1.array" />.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ArrayPoolBufferWriter`1.Create">
            <summary>
            Creates a new instance of the <see cref="T:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ArrayPoolBufferWriter`1" /> struct.
            </summary>
        </member>
        <member name="P:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ArrayPoolBufferWriter`1.Span">
            <summary>
            Gets a <see cref="T:System.ReadOnlySpan`1" /> with the current items.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ArrayPoolBufferWriter`1.Add(`0)">
            <summary>
            Adds a new item to the current collection.
            </summary>
            <param name="item">The item to add.</param>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ArrayPoolBufferWriter`1.Reset">
            <summary>
            Resets the underlying array and the stored items.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ArrayPoolBufferWriter`1.ResizeBuffer">
            <summary>
            Resizes <see cref="F:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ArrayPoolBufferWriter`1.array" /> when there is no space left for new items.
            </summary>
        </member>
        <member name="M:Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger.ArrayPoolBufferWriter`1.Dispose">
            <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
            <filterpriority>2</filterpriority>
        </member>
        <member name="T:Microsoft.Collections.Extensions.DictionarySlim`2">
            <summary>
             A lightweight Dictionary with three principal differences compared to <see cref="T:System.Collections.Generic.Dictionary`2" />
            
             1) It is possible to do "get or add" in a single lookup. For value types, this also saves a copy of the value.
             2) It assumes it is cheap to equate values.
             3) It assumes the keys implement <see cref="T:System.IEquatable`1" /> and they are cheap and sufficient.
             </summary>
            <typeparam name="TKey">The type of keys in the dictionary.</typeparam>
            <typeparam name="TValue">The type of values in the dictionary.</typeparam>
            <remarks>
             1) This avoids having to do separate lookups (<see cref="M:System.Collections.Generic.Dictionary`2.TryGetValue(`0,`1@)" />
             followed by <see cref="M:System.Collections.Generic.Dictionary`2.Add(`0,`1)" />.
             There is not currently an API exposed to get a value by ref without adding if the key is not present.
             2) This means it can save space by not storing hash codes.
             3) This means it can avoid storing a comparer, and avoid the likely virtual call to a comparer.
             </remarks>
        </member>
        <member name="F:Microsoft.Collections.Extensions.DictionarySlim`2.InitialEntries">
            <summary>
            A reusable array of <see cref="T:Microsoft.Collections.Extensions.DictionarySlim`2.Entry" /> items with a single value.
            This is used when a new <see cref="T:Microsoft.Collections.Extensions.DictionarySlim`2" /> instance is
            created, or when one is cleared. The first item being added to this collection
            will immediately cause the first resize (see <see cref="M:Microsoft.Collections.Extensions.DictionarySlim`2.AddKey(`0,System.Int32)" /> for more info).
            </summary>
        </member>
        <member name="F:Microsoft.Collections.Extensions.DictionarySlim`2.count">
            <summary>
            The current number of items stored in the map.
            </summary>
        </member>
        <member name="F:Microsoft.Collections.Extensions.DictionarySlim`2.freeList">
            <summary>
            The 1-based index for the start of the free list within <see cref="F:Microsoft.Collections.Extensions.DictionarySlim`2.entries" />.
            </summary>
        </member>
        <member name="F:Microsoft.Collections.Extensions.DictionarySlim`2.buckets">
            <summary>
            The array of 1-based indices for the <see cref="T:Microsoft.Collections.Extensions.DictionarySlim`2.Entry" /> items stored in <see cref="F:Microsoft.Collections.Extensions.DictionarySlim`2.entries" />.
            </summary>
        </member>
        <member name="F:Microsoft.Collections.Extensions.DictionarySlim`2.entries">
            <summary>
            The array of currently stored key-value pairs (ie. the lists for each hash group).
            </summary>
        </member>
        <member name="M:Microsoft.Collections.Extensions.DictionarySlim`2.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.Collections.Extensions.DictionarySlim`2" /> class.
            </summary>
        </member>
        <member name="P:Microsoft.Collections.Extensions.DictionarySlim`2.Count">
            <summary>
            Gets the count of entries in the dictionary.
            </summary>
        </member>
        <member name="P:Microsoft.Collections.Extensions.DictionarySlim`2.Item(`0)" />
        <member name="M:Microsoft.Collections.Extensions.DictionarySlim`2.Clear">
            <summary>
            Clears the current dictionary.
            </summary>
        </member>
        <member name="M:Microsoft.Collections.Extensions.DictionarySlim`2.ContainsKey(`0)">
            <summary>
            Checks whether or not the dictionary contains a pair with a specified key.
            </summary>
            <param name="key">The key to look for.</param>
            <returns>Whether or not the key was present in the dictionary.</returns>
        </member>
        <member name="M:Microsoft.Collections.Extensions.DictionarySlim`2.TryGetValue(`0,`1@)">
            <summary>
            Gets the value if present for the specified key.
            </summary>
            <param name="key">The key to look for.</param>
            <param name="value">The value found, otherwise <see langword="default" />.</param>
            <returns>Whether or not the key was present.</returns>
        </member>
        <member name="M:Microsoft.Collections.Extensions.DictionarySlim`2.TryRemove(`0)" />
        <member name="M:Microsoft.Collections.Extensions.DictionarySlim`2.TryRemove(`0,`1@)">
            <summary>
            Tries to remove a value with a specified key, if present.
            </summary>
            <param name="key">The key of the value to remove.</param>
            <param name="result">The removed value, if it was present.</param>
            <returns>Whether or not the key was present.</returns>
        </member>
        <member name="M:Microsoft.Collections.Extensions.DictionarySlim`2.GetOrAddValueRef(`0)">
            <summary>
            Gets the value for the specified key, or, if the key is not present,
            adds an entry and returns the value by ref. This makes it possible to
            add or update a value in a single look up operation.
            </summary>
            <param name="key">Key to look for</param>
            <returns>Reference to the new or existing value</returns>
        </member>
        <member name="M:Microsoft.Collections.Extensions.DictionarySlim`2.AddKey(`0,System.Int32)">
            <summary>
            Creates a slot for a new value to add for a specified key.
            </summary>
            <param name="key">The key to use to add the new value.</param>
            <param name="bucketIndex">The target bucked index to use.</param>
            <returns>A reference to the slot for the new value to add.</returns>
        </member>
        <member name="M:Microsoft.Collections.Extensions.DictionarySlim`2.Resize">
            <summary>
            Resizes the current dictionary to reduce the number of collisions
            </summary>
        </member>
        <member name="M:Microsoft.Collections.Extensions.DictionarySlim`2.GetEnumerator">
            <summary>Returns an enumerator that iterates through the collection.</summary>
            <returns>An enumerator that can be used to iterate through the collection.</returns>
            <filterpriority>1</filterpriority>
        </member>
        <member name="M:Microsoft.Collections.Extensions.DictionarySlim`2.ThrowArgumentExceptionForKeyNotFound(`0)">
            <summary>
            Throws an <see cref="T:System.ArgumentException" /> when trying to load an element with a missing key.
            </summary>
        </member>
        <member name="M:Microsoft.Collections.Extensions.DictionarySlim`2.ThrowInvalidOperationExceptionForMaxCapacityExceeded">
            <summary>
            Throws an <see cref="T:System.InvalidOperationException" /> when trying to resize over the maximum capacity.
            </summary>
        </member>
        <member name="T:Microsoft.Collections.Extensions.DictionarySlim`2.Entry">
            <summary>
            A type representing a map entry, ie. a node in a given list.
            </summary>
        </member>
        <member name="F:Microsoft.Collections.Extensions.DictionarySlim`2.Entry.Key">
            <summary>
            The key for the value in the current node.
            </summary>
        </member>
        <member name="F:Microsoft.Collections.Extensions.DictionarySlim`2.Entry.Value">
            <summary>
            The value in the current node, if present.
            </summary>
        </member>
        <member name="F:Microsoft.Collections.Extensions.DictionarySlim`2.Entry.Next">
            <summary>
            The 0-based index for the next node in the current list.
            </summary>
        </member>
        <member name="T:Microsoft.Collections.Extensions.DictionarySlim`2.Enumerator">
            <summary>
            Enumerator for <see cref="T:Microsoft.Collections.Extensions.DictionarySlim`2" />.
            </summary>
        </member>
        <member name="M:Microsoft.Collections.Extensions.DictionarySlim`2.Enumerator.MoveNext">
            <summary>Advances the enumerator to the next element of the collection.</summary>
            <returns>true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.</returns>
            <exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created. </exception>
            <filterpriority>2</filterpriority>
        </member>
        <member name="P:Microsoft.Collections.Extensions.DictionarySlim`2.Enumerator.Key">
            <summary>
            Gets the current key.
            </summary>
        </member>
        <member name="P:Microsoft.Collections.Extensions.DictionarySlim`2.Enumerator.Value">
            <summary>
            Gets the current value.
            </summary>
        </member>
        <member name="T:Microsoft.Collections.Extensions.HashHelpers">
            <summary>
            A helper class for <see cref="T:Microsoft.Collections.Extensions.DictionarySlim`2" />.
            </summary>
        </member>
        <member name="F:Microsoft.Collections.Extensions.HashHelpers.SizeOneIntArray">
            <summary>
            An array of type <see cref="T:System.Int32" /> of size 1.
            </summary>
        </member>
        <member name="T:Microsoft.Collections.Extensions.IDictionarySlim">
            <summary>
            A base interface masking <see cref="T:Microsoft.Collections.Extensions.DictionarySlim`2" /> instances and exposing non-generic functionalities.
            </summary>
        </member>
        <member name="P:Microsoft.Collections.Extensions.IDictionarySlim.Count">
            <summary>
            Gets the count of entries in the dictionary.
            </summary>
        </member>
        <member name="M:Microsoft.Collections.Extensions.IDictionarySlim.Clear">
            <summary>
            Clears the current dictionary.
            </summary>
        </member>
        <member name="T:Microsoft.Collections.Extensions.IDictionarySlim`2">
            <summary>
            An interface providing key type contravariant and value type covariant access
            to a <see cref="T:Microsoft.Collections.Extensions.DictionarySlim`2" /> instance.
            </summary>
            <typeparam name="TKey">The contravariant type of keys in the dictionary.</typeparam>
            <typeparam name="TValue">The covariant type of values in the dictionary.</typeparam>
        </member>
        <member name="P:Microsoft.Collections.Extensions.IDictionarySlim`2.Item(`0)">
            <summary>
            Gets the value with the specified key.
            </summary>
            <param name="key">The key to look for.</param>
            <returns>The returned value.</returns>
            <exception cref="T:System.ArgumentException">Thrown if the key wasn't present.</exception>
        </member>
        <member name="T:Microsoft.Collections.Extensions.IDictionarySlim`1">
            <summary>
            An interface providing key type contravariant access to a <see cref="T:Microsoft.Collections.Extensions.DictionarySlim`2" /> instance.
            </summary>
            <typeparam name="TKey">The contravariant type of keys in the dictionary.</typeparam>
        </member>
        <member name="M:Microsoft.Collections.Extensions.IDictionarySlim`1.TryRemove(`0)">
            <summary>
            Tries to remove a value with a specified key, if present.
            </summary>
            <param name="key">The key of the value to remove.</param>
            <returns>Whether or not the key was present.</returns>
        </member>
    </members>
</doc>