text:
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>FluentAssertions</name>
    </assembly>
    <members>
        <member name="M:FluentAssertions.AndConstraint`1.#ctor(`0)">

            Initializes a new instance of the <see cref="T:System.Object"/> class.

        </member>
        <member name="T:FluentAssertions.AssertionExtensions">

            Contains extension methods for custom assertions in unit tests.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Invoking``1(``0,System.Action{``0})">

            Invokes the specified action on an subject so that you can chain it with any of the ShouldThrow or ShouldNotThrow
            overloads.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.ExecutionTimeOf``1(``0,System.Linq.Expressions.Expression{System.Action{``0}})">

            Provides methods for asserting the execution time of a method or property.

            <param name="subject">The object that exposes the method or property.</param>
            <param name="action">A reference to the method or property to measure the execution time of.</param>
            <returns>
            Returns an object for asserting that the execution time matches certain conditions.
            </returns>
        </member>
        <member name="M:FluentAssertions.AssertionExtensions.ExecutionTime(System.Action)">

            Provides methods for asserting the execution time of a method or property.

            <param name="action">A reference to the method or property to measure the execution time of.</param>
            <returns>
            Returns an object for asserting that the execution time matches certain conditions.
            </returns>
        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Xml.Linq.XDocument)">

            Returns an <see cref="T:FluentAssertions.Xml.XDocumentAssertions"/> object that can be used to assert the
            current <see cref="T:System.Xml.Linq.XElement"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Xml.Linq.XElement)">

            Returns an <see cref="T:FluentAssertions.Xml.XElementAssertions"/> object that can be used to assert the
            current <see cref="T:System.Xml.Linq.XElement"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Xml.Linq.XAttribute)">

            Returns an <see cref="T:FluentAssertions.Xml.XAttributeAssertions"/> object that can be used to assert the
            current <see cref="T:System.Xml.Linq.XAttribute"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.ShouldThrow``1(System.Action,System.String,System.Object[])">

            Asserts that the <paramref name="action"/> throws an exception.

            <param name="action">A reference to the method or property.</param>
            <typeparam name="TException">
            The type of the exception it should throw.
            </typeparam>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
            <returns>
            Returns an object that allows asserting additional members of the thrown exception.
            </returns>
        </member>
        <member name="M:FluentAssertions.AssertionExtensions.ShouldNotThrow``1(System.Action,System.String,System.Object[])">

            Asserts that the <paramref name="action"/> does not throw a particular exception.

            <param name="action">The current method or property.</param>
            <typeparam name="TException">
            The type of the exception it should not throw. Any other exceptions are ignored and will satisfy the assertion.
            </typeparam>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.AssertionExtensions.ShouldNotThrow(System.Action,System.String,System.Object[])">

            Asserts that the <paramref name="action"/> does not throw any exception at all.

            <param name="action">The current method or property.</param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Enumerating(System.Func{System.Collections.IEnumerable})">

            Forces enumerating a collection. Should be used to assert that a method that uses the
            <c>yield</c> keyword throws a particular exception.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Enumerating``1(System.Func{System.Collections.Generic.IEnumerable{``0}})">

            Forces enumerating a collection. Should be used to assert that a method that uses the
            <c>yield</c> keyword throws a particular exception.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Object)">

            Returns an <see cref="T:FluentAssertions.Primitives.ObjectAssertions"/> object that can be used to assert the
            current <see cref="T:System.Object"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Boolean)">

            Returns an <see cref="T:FluentAssertions.Primitives.BooleanAssertions"/> object that can be used to assert the
            current <see cref="T:System.Boolean"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Nullable{System.Boolean})">

            Returns an <see cref="T:FluentAssertions.Primitives.NullableBooleanAssertions"/> object that can be used to assert the
            current nullable <see cref="T:System.Boolean"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Guid)">

            Returns an <see cref="T:FluentAssertions.Primitives.GuidAssertions"/> object that can be used to assert the
            current <see cref="T:System.Guid"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Nullable{System.Guid})">

            Returns an <see cref="T:FluentAssertions.Primitives.NullableGuidAssertions"/> object that can be used to assert the
            current nullable <see cref="T:System.Guid"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Collections.IEnumerable)">

            Returns an <see cref="T:FluentAssertions.Collections.NonGenericCollectionAssertions"/> object that can be used to assert the
            current <see cref="T:System.Collections.IEnumerable"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should``1(System.Collections.Generic.IEnumerable{``0})">

            Returns an <see cref="T:FluentAssertions.Collections.GenericCollectionAssertions`1"/> object that can be used to assert the
            current <see cref="T:System.Collections.Generic.IEnumerable`1"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should``2(System.Collections.Generic.IDictionary{``0,``1})">

            Returns an <see cref="T:FluentAssertions.Collections.GenericDictionaryAssertions`2"/> object that can be used to assert the
            current <see cref="T:System.Collections.Generic.IDictionary`2"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.DateTime)">

            Returns an <see cref="T:FluentAssertions.Primitives.DateTimeAssertions"/> object that can be used to assert the
            current <see cref="T:System.DateTime"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Nullable{System.DateTime})">

            Returns an <see cref="T:FluentAssertions.Primitives.NullableDateTimeAssertions"/> object that can be used to assert the
            current nullable <see cref="T:System.DateTime"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should``1(System.IComparable{``0})">

            Returns an <see cref="T:FluentAssertions.Numeric.ComparableTypeAssertions`1"/> object that can be used to assert the
            current <see cref="T:System.IComparable`1"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Int32)">

            Returns an <see cref="T:FluentAssertions.Numeric.NumericAssertions`1"/> object that can be used to assert the
            current <see cref="T:System.Int32"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Nullable{System.Int32})">

            Returns an <see cref="T:FluentAssertions.Numeric.NullableNumericAssertions`1"/> object that can be used to assert the
            current nullable <see cref="T:System.Int32"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Decimal)">

            Returns an <see cref="T:FluentAssertions.Numeric.NumericAssertions`1"/> object that can be used to assert the
            current <see cref="T:System.Decimal"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Nullable{System.Decimal})">

            Returns an <see cref="T:FluentAssertions.Numeric.NullableNumericAssertions`1"/> object that can be used to assert the
            current nullable <see cref="T:System.Decimal"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Byte)">

            Returns an <see cref="T:FluentAssertions.Numeric.NumericAssertions`1"/> object that can be used to assert the
            current <see cref="T:System.Byte"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Nullable{System.Byte})">

            Returns an <see cref="T:FluentAssertions.Numeric.NullableNumericAssertions`1"/> object that can be used to assert the
            current nullable <see cref="T:System.Byte"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Int16)">

            Returns an <see cref="T:FluentAssertions.Numeric.NumericAssertions`1"/> object that can be used to assert the
            current <see cref="T:System.Int16"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Nullable{System.Int16})">

            Returns an <see cref="T:FluentAssertions.Numeric.NullableNumericAssertions`1"/> object that can be used to assert the
            current nullable <see cref="T:System.Int16"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Int64)">

            Returns an <see cref="T:FluentAssertions.Numeric.NumericAssertions`1"/> object that can be used to assert the
            current <see cref="T:System.Int64"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Nullable{System.Int64})">

            Returns an <see cref="T:FluentAssertions.Numeric.NullableNumericAssertions`1"/> object that can be used to assert the
            current nullable <see cref="T:System.Int64"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Single)">

            Returns an <see cref="T:FluentAssertions.Numeric.NumericAssertions`1"/> object that can be used to assert the
            current <see cref="T:System.Single"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Nullable{System.Single})">

            Returns an <see cref="T:FluentAssertions.Numeric.NullableNumericAssertions`1"/> object that can be used to assert the
            current nullable <see cref="T:System.Single"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Double)">

            Returns an <see cref="T:FluentAssertions.Numeric.NumericAssertions`1"/> object that can be used to assert the
            current <see cref="T:System.Double"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Nullable{System.Double})">

            Returns an <see cref="T:FluentAssertions.Numeric.NullableNumericAssertions`1"/> object that can be used to assert the
            current nullable <see cref="T:System.Double"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.String)">

            Returns an <see cref="T:FluentAssertions.Primitives.StringAssertions"/> object that can be used to assert the
            current <see cref="T:System.String"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.TimeSpan)">

            Returns an <see cref="T:FluentAssertions.Primitives.SimpleTimeSpanAssertions"/> object that can be used to assert the
            current <see cref="T:System.TimeSpan"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Nullable{System.TimeSpan})">

            Returns an <see cref="T:FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions"/> object that can be used to assert the
            current nullable <see cref="T:System.TimeSpan"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Type)">

            Returns a <see cref="T:FluentAssertions.Types.TypeAssertions"/> object that can be used to assert the
            current <see cref="T:System.Type"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(FluentAssertions.Types.TypeSelector)">

            Returns a <see cref="T:FluentAssertions.Types.TypeAssertions"/> object that can be used to assert the
            current <see cref="T:System.Type"/>.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Reflection.MethodInfo)">

            Returns a <see cref="T:FluentAssertions.Types.MethodInfoAssertions"/> object that can be used to assert the current <see cref="T:System.Reflection.MethodInfo"/>.

            <seealso cref="T:FluentAssertions.Types.TypeAssertions"/>
        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(FluentAssertions.Types.MethodInfoSelector)">

            Returns a <see cref="T:FluentAssertions.Types.MethodInfoAssertions"/> object that can be used to assert the methods returned by the
            current <see cref="T:FluentAssertions.Types.MethodInfoSelector"/>.

            <seealso cref="T:FluentAssertions.Types.TypeAssertions"/>
        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(System.Reflection.PropertyInfo)">

            Returns a <see cref="T:FluentAssertions.Types.PropertyInfoAssertions"/> object that can be used to assert the
            current <see cref="T:FluentAssertions.Types.PropertyInfoSelector"/>.

            <seealso cref="T:FluentAssertions.Types.TypeAssertions"/>
        </member>
        <member name="M:FluentAssertions.AssertionExtensions.Should(FluentAssertions.Types.PropertyInfoSelector)">

            Returns a <see cref="T:FluentAssertions.Types.PropertyInfoAssertions"/> object that can be used to assert the properties returned by the
            current <see cref="T:FluentAssertions.Types.PropertyInfoSelector"/>.

            <seealso cref="T:FluentAssertions.Types.TypeAssertions"/>
        </member>
        <member name="M:FluentAssertions.AssertionExtensions.ShouldHave``1(``0)">

            Asserts that the properties of an object matches those of another object.

        </member>
        <member name="M:FluentAssertions.AssertionExtensions.ShouldBeEquivalentTo``1(``0,System.Object,System.String,System.Object[])">

            Asserts that an object is equivalent to another object.

            <remarks>
            Objects are equivalent when both object graphs have equally named properties with the same value,
            irrespective of the type of those objects. Two properties are also equal if one type can be converted to another and the result is equal.
            The type of a collection property is ignored as long as the collection implements <see cref="T:System.Collections.IEnumerable"/> and all
            items in the collection are structurally equal.
            Notice that actual behavior is determined by the <see cref="F:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Default"/> instance of the
            <see cref="T:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1"/> class.
            </remarks>
            <param name="reason">
            An optional formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the
            assertion is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.AssertionExtensions.ShouldBeEquivalentTo``1(``0,System.Object,System.Func{FluentAssertions.Equivalency.EquivalencyAssertionOptions{``0},FluentAssertions.Equivalency.EquivalencyAssertionOptions{``0}},System.String,System.Object[])">

            Asserts that an object is equivalent to another object.

            <remarks>
            Objects are equivalent when both object graphs have equally named properties with the same value,
            irrespective of the type of those objects. Two properties are also equal if one type can be converted to another and the result is equal.
            The type of a collection property is ignored as long as the collection implements <see cref="T:System.Collections.IEnumerable"/> and all
            items in the collection are structurally equal.
            </remarks>
            <param name="config">
            A reference to the <see cref="F:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Default"/> configuration object that can be used
            to influence the way the object graphs are compared. You can also provide an alternative instance of the
            <see cref="T:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1"/> class.
            </param>
            <param name="reason">
            An optional formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the
            assertion is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.AssertionExtensions.As``1(System.Object)">

            Safely casts the specified object to the type specified through <typeparamref name="TTo"/>.

            <remarks>
            Has been introduced to allow casting objects without breaking the fluent API.
            </remarks>
            <typeparam name="TTo"></typeparam>
        </member>
        <member name="T:FluentAssertions.Collections.CollectionAssertions`2">

            Contains a number of methods to assert that an <see cref="T:System.Collections.IEnumerable"/> is in the expected state.

        </member>
        <member name="T:FluentAssertions.Primitives.ReferenceTypeAssertions`2">

            Contains a number of methods to assert that a reference type object is in the expected state.

        </member>
        <member name="M:FluentAssertions.Primitives.ReferenceTypeAssertions`2.BeOfType``1(System.String,System.Object[])">

            Asserts that the object is of the specified type <typeparamref name="T"/>.

            <typeparam name="T">The expected type of the object.</typeparam>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.ReferenceTypeAssertions`2.BeAssignableTo``1(System.String,System.Object[])">

            Asserts that the object is assignable to a variable of type <typeparamref name="T"/>.

            <typeparam name="T">The type to which the object should be assignable.</typeparam>
            <param name="reason">The reason why the object should be assignable to the type.</param>
            <param name="reasonArgs">The parameters used when formatting the <paramref name="reason"/>.</param>
            <returns>An <see cref="T:FluentAssertions.AndConstraint`1"/> which can be used to chain assertions.</returns>
        </member>
        <member name="M:FluentAssertions.Primitives.ReferenceTypeAssertions`2.Match(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}},System.String,System.Object[])">

            Asserts that the <paramref name="predicate"/> is satisfied.

            <param name="predicate">The predicate which must be statisfied by the <typeparamref name="TSubject"/>.</param>
            <param name="reason">The reason why the predicate should be satisfied.</param>
            <param name="reasonArgs">The parameters used when formatting the <paramref name="reason"/>.</param>
            <returns>An <see cref="T:FluentAssertions.AndConstraint`1"/> which can be used to chain assertions.</returns>
        </member>
        <member name="M:FluentAssertions.Primitives.ReferenceTypeAssertions`2.Match``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String,System.Object[])">

            Asserts that the <paramref name="predicate"/> is satisfied.

            <param name="predicate">The predicate which must be statisfied by the <typeparamref name="TSubject"/>.</param>
            <param name="reason">The reason why the predicate should be satisfied.</param>
            <param name="reasonArgs">The parameters used when formatting the <paramref name="reason"/>.</param>
            <returns>An <see cref="T:FluentAssertions.AndConstraint`1"/> which can be used to chain assertions.</returns>
        </member>
        <member name="P:FluentAssertions.Primitives.ReferenceTypeAssertions`2.Subject">

            Gets the object which value is being asserted.

        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.HaveCount(System.Int32,System.String,System.Object[])">

            Asserts that the number of items in the collection matches the supplied <paramref name="expected"/> amount.

            <param name="expected">The expected number of items in the collection.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.HaveCount(System.Linq.Expressions.Expression{System.Func{System.Int32,System.Boolean}},System.String,System.Object[])">

            Asserts that the number of items in the collection matches a condition stated by the <paramref name="countPredicate"/>.

            <param name="countPredicate">A predicate that yields the number of items that is expected to be in the collection.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.BeEmpty(System.String,System.Object[])">

            Asserts that the collection does not contain any items.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.NotBeEmpty(System.String,System.Object[])">

            Asserts that the collection contains at least 1 item.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.OnlyHaveUniqueItems(System.String,System.Object[])">

            Asserts that the collection does not contain any duplicate items.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.NotContainNulls(System.String,System.Object[])">

            Asserts that the collection does not contain any <c>null</c> items.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.Equal(System.Object[])">

            Expects the current collection to contain all the same elements in the same order as the collection identified by
            <paramref name="elements"/>. Elements are compared using their <see cref="M:System.Object.Equals(System.Object)"/>.

            <param name="elements">A params array with the expected elements.</param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.Equal(System.Collections.IEnumerable,System.String,System.Object[])">

            Expects the current collection to contain all the same elements in the same order as the collection identified by
            <paramref name="expected"/>. Elements are compared using their <see cref="M:System.Object.Equals(System.Object)"/>.

            <param name="expected">An <see cref="T:System.Collections.IEnumerable"/> with the expected elements.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.NotEqual(System.Collections.IEnumerable,System.String,System.Object[])">

            Expects the current collection not to contain all the same elements in the same order as the collection identified by
            <paramref name="unexpected"/>. Elements are compared using their <see cref="M:System.Object.Equals(System.Object)"/>.

            <param name="unexpected">An <see cref="T:System.Collections.IEnumerable"/> with the elements that are not expected.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.BeEquivalentTo(System.Object[])">

            Expects the current collection to contain all elements of the collection identified by <paramref name="elements"/>,
            regardless of the order. Elements are compared using their <see cref="M:System.Object.Equals(System.Object)"/>.

            <param name="elements">A params array with the expected elements.</param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.BeEquivalentTo(System.Collections.IEnumerable,System.String,System.Object[])">

            Expects the current collection to contain all elements of the collection identified by <paramref name="expected"/>,
            regardless of the order. Elements are compared using their <see cref="M:System.Object.Equals(System.Object)"/>.

            <param name="expected">An <see cref="T:System.Collections.IEnumerable"/> with the expected elements.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.NotBeEquivalentTo(System.Collections.IEnumerable,System.String,System.Object[])">

            Expects the current collection not to contain all elements of the collection identified by <paramref name="unexpected"/>,
            regardless of the order. Elements are compared using their <see cref="M:System.Object.Equals(System.Object)"/>.

            <param name="unexpected">An <see cref="T:System.Collections.IEnumerable"/> with the unexpected elements.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.ContainItemsAssignableTo``1(System.String,System.Object[])">

            Asserts that the current collection only contains items that are assignable to the type <typeparamref name="T"/>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.Contain(System.Collections.IEnumerable,System.String,System.Object[])">

            Expects the current collection to contain the specified elements in any order. Elements are compared
            using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">An <see cref="T:System.Collections.IEnumerable"/> with the expected elements.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.ContainInOrder(System.Object[])">

            Expects the current collection to contain the specified elements in the exact same order. Elements are compared
            using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">An <see cref="T:System.Collections.IEnumerable"/> with the expected elements.</param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.ContainInOrder(System.Collections.IEnumerable,System.String,System.Object[])">

            Expects the current collection to contain the specified elements in the exact same order. Elements are compared
            using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">An <see cref="T:System.Collections.IEnumerable"/> with the expected elements.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.BeInAscendingOrder(System.String,System.Object[])">

            Expects the current collection to have all elements in ascending order. Elements are compared
            using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.BeInDescendingOrder(System.String,System.Object[])">

            Expects the current collection to have all elements in descending order. Elements are compared
            using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.BeInOrder(FluentAssertions.Collections.SortOrder,System.String,System.Object[])">

            Expects the current collection to have all elements in the specified <paramref name="expectedOrder"/>.
            Elements are compared using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.NotBeAscendingInOrder(System.String,System.Object[])">

            Asserts the current collection does not have all elements in ascending order. Elements are compared
            using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.NotBeDescendingInOrder(System.String,System.Object[])">

            Asserts the current collection does not have all elements in descending order. Elements are compared
            using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.NotBeInOrder(FluentAssertions.Collections.SortOrder,System.String,System.Object[])">

            Asserts the current collection does not have all elements in ascending order. Elements are compared
            using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.BeSubsetOf(System.Collections.IEnumerable,System.String,System.Object[])">

            Asserts that the collection is a subset of the <paramref name="expectedSuperset"/>.

            <param name="expectedSuperset">An <see cref="T:System.Collections.IEnumerable"/> with the expected superset.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.NotBeSubsetOf(System.Collections.IEnumerable,System.String,System.Object[])">

            Asserts that the collection is not a subset of the <paramref name="unexpectedSuperset"/>.

            <param name="unexpectedSuperset">An <see cref="T:System.Collections.IEnumerable"/> with the unexpected superset.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.HaveSameCount(System.Collections.IEnumerable,System.String,System.Object[])">

            Assert that the current collection has the same number of elements as <paramref name="otherCollection"/>.

            <param name="otherCollection">The other collection with the same expected number of elements</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.BeNull(System.String,System.Object[])">

            Asserts that the current collection has not been initialized yet with an actual collection.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.NotBeNull(System.String,System.Object[])">

            Asserts that the current collection has been initialized with an actual collection.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.HaveElementAt(System.Int32,System.Object,System.String,System.Object[])">

            Asserts that the current collection has the supplied <paramref name="element"/> at the
            supplied <paramref name="index"/>.

            <param name="index">The index where the element is expected</param>
            <param name="element">The expected element</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.NotContain(System.Object,System.String,System.Object[])">

            Asserts that the current collection does not contain the supplied <paramref name="unexpected"/> item.

            <param name="unexpected">The element that is not expected to be in the collection</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.IntersectWith(System.Collections.IEnumerable,System.String,System.Object[])">

            Asserts that the collection shares one or more items with the specified <paramref name="otherCollection"/>.

            <param name="otherCollection">The <see cref="T:System.Collections.IEnumerable"/> with the expected shared items.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.CollectionAssertions`2.NotIntersectWith(System.Collections.IEnumerable,System.String,System.Object[])">

            Asserts that the collection does not share any items with the specified <paramref name="otherCollection"/>.

            <param name="otherCollection">The <see cref="T:System.Collections.IEnumerable"/> to compare to.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="T:FluentAssertions.Collections.GenericCollectionAssertions`1">

            Contains a number of methods to assert that an <see cref="T:System.Collections.Generic.IEnumerable`1"/> is in the expectation state.

        </member>
        <member name="M:FluentAssertions.Collections.GenericCollectionAssertions`1.Equal(System.Collections.Generic.IEnumerable{`0},System.Func{`0,`0,System.Boolean},System.String,System.Object[])">

            Asserts that two collections contain the same items in the same order, where equality is determined using a
            predicate.

            <param name="expectation">
            The collection to compare the subject with.
            </param>
            <param name="predicate">
            A predicate the is used to determine whether two objects should be treated as equal.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericCollectionAssertions`1.Contain(`0,System.String,System.Object[])">

            Asserts that the collection contains the specified item.

            <param name="expected">The expectation item.</param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericCollectionAssertions`1.Contain(System.Collections.Generic.IEnumerable{`0},`0[])">

            Asserts that the collection contains some extra items in addition to the original items.

            <param name="expectedItemsList">An <see cref="T:System.Collections.Generic.IEnumerable`1"/> of expectation items.</param>
            <param name="additionalExpectedItems">Additional items that are expectation to be contained by the collection.</param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericCollectionAssertions`1.Contain(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}},System.String,System.Object[])">

            Asserts that the collection contains at least one item that matches the predicate.

            <param name="predicate">A predicate to match the items in the collection against.</param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericCollectionAssertions`1.OnlyContain(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}},System.String,System.Object[])">

            Asserts that the collection only contains items that match a predicate.

            <param name="predicate">A predicate to match the items in the collection against.</param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericCollectionAssertions`1.NotContain(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}},System.String,System.Object[])">

            Asserts that the collection does not contain any items that match the predicate.

            <param name="predicate">A predicate to match the items in the collection against.</param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericCollectionAssertions`1.ContainSingle(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}},System.String,System.Object[])">

            Expects the current collection to contain only a single item matching the specified <paramref name="predicate"/>.

            <param name="predicate">The predictes that will be used to find the matching items.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="T:FluentAssertions.Collections.GenericDictionaryAssertions`2">

            Contains a number of methods to assert that an <see cref="T:System.Collections.Generic.IDictionary`2"/> is in the expected state.

        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.BeNull(System.String,System.Object[])">

            Asserts that the current dictionary has not been initialized yet with an actual dictionary.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.NotBeNull(System.String,System.Object[])">

            Asserts that the current dictionary has been initialized with an actual dictionary.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.HaveCount(System.Int32,System.String,System.Object[])">

            Asserts that the number of items in the dictionary matches the supplied <paramref name="expected"/> amount.

            <param name="expected">The expected number of items.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.HaveCount(System.Linq.Expressions.Expression{System.Func{System.Int32,System.Boolean}},System.String,System.Object[])">

            Asserts that the number of items in the dictionary matches a condition stated by a predicate.

            <param name="countPredicate">The predicate which must be statisfied by the amount of items.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.BeEmpty(System.String,System.Object[])">

            Asserts that the dictionary does not contain any items.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.NotBeEmpty(System.String,System.Object[])">

            Asserts that the dictionary contains at least 1 item.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.Equal(System.Collections.Generic.IDictionary{`0,`1},System.String,System.Object[])">

            Asserts that the current dictionary contains all the same key-value pairs as the
            specified <paramref name="expected"/> dictionary. Keys and values are compared using
            their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">The expected dictionary</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.NotEqual(System.Collections.Generic.IDictionary{`0,`1},System.String,System.Object[])">

            Asserts the current dictionary not to contain all the same key-value pairs as the
            specified <paramref name="unexpected"/> dictionary. Keys and values are compared using
            their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="unexpected">The unexpected dictionary</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.ContainKey(`0,System.String,System.Object[])">

            Asserts that the dictionary contains the specified key. Keys are compared using
            their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">The expected key</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.ContainKeys(`0[])">

            Asserts that the dictionary contains all of the specified keys. Keys are compared using
            their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">The expected keys</param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.ContainKeys(System.Collections.Generic.IEnumerable{`0},System.String,System.Object[])">

            Asserts that the dictionary contains all of the specified keys. Keys are compared using
            their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">The expected keys</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.NotContainKey(`0,System.String,System.Object[])">

            Asserts that the current dictionary does not contain the specified <paramref name="unexpected"/> key.
            Keys are compared using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="unexpected">The unexpected key</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.ContainValue(`1,System.String,System.Object[])">

            Asserts that the dictionary contains the specified value. Values are compared using
            their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">The expected value</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.ContainValues(`1[])">

            Asserts that the dictionary contains all of the specified values. Values are compared using
            their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">The expected values</param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.ContainValues(System.Collections.Generic.IEnumerable{`1},System.String,System.Object[])">

            Asserts that the dictionary contains all of the specified values. Values are compared using
            their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">The expected values</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.NotContainValue(`1,System.String,System.Object[])">

            Asserts that the current dictionary does not contain the specified <paramref name="unexpected"/> value.
            Values are compared using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="unexpected">The unexpected value</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.Contain(System.Collections.Generic.KeyValuePair{`0,`1},System.String,System.Object[])">

            Asserts that the current dictionary contains the specified <paramref name="expected"/>.
            Keys and values are compared using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">The expected <see cref="T:System.Collections.Generic.KeyValuePair`2"/></param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.Contain(`0,`1,System.String,System.Object[])">

            Asserts that the current dictionary contains the specified <paramref name="value"/> for the supplied <paramref name="key"/>. Values are compared using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="key">The key for which to validate the value</param>
            <param name="value">The value to validate</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.NotContain(System.Collections.Generic.KeyValuePair{`0,`1},System.String,System.Object[])">

            Asserts that the current dictionary does not contain the specified <paramref name="item"/>.
            Keys and values are compared using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="item">The unexpected <see cref="T:System.Collections.Generic.KeyValuePair`2"/></param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Collections.GenericDictionaryAssertions`2.NotContain(`0,`1,System.String,System.Object[])">

            Asserts that the current dictionary does not contain the specified <paramref name="value"/> for the
            supplied <paramref name="key"/>. Values are compared using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="key">The key for which to validate the value</param>
            <param name="value">The value to validate</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Collections.GenericDictionaryAssertions`2.Subject">

            Gets the object which value is being asserted.

        </member>
        <member name="T:FluentAssertions.Collections.NonGenericCollectionAssertions">

            Contains a number of methods to assert that an <see cref="T:System.Collections.IEnumerable"/> is in the expected state.

        </member>
        <member name="M:FluentAssertions.Collections.NonGenericCollectionAssertions.Contain(System.Object,System.String,System.Object[])">

            Asserts that the current collection contains the specified <paramref name="expected"/> object. Elements are compared
            using their <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">An object, or <see cref="T:System.Collections.IEnumerable"/> of objects that are expected to be in the collection.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Common.ExpressionExtensions.GetPropertyPath``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})">

            Gets a dotted path of property names representing the property expression. E.g. Parent.Child.Sibling.Name.

        </member>
        <member name="M:FluentAssertions.Common.StringExtensions.IndexOfFirstMismatch(System.String,System.String)">

            Finds the first index at which the <paramref name="value"/> does not match the <paramref name="expected"/>
            string anymore, including the exact casing.

        </member>
        <member name="M:FluentAssertions.Common.StringExtensions.IndexOfFirstMismatch(System.String,System.String,System.StringComparison)">

            Finds the first index at which the <paramref name="value"/> does not match the <paramref name="expected"/>
            string anymore, accounting for the specified <paramref name="stringComparison"/>.

        </member>
        <member name="M:FluentAssertions.Common.StringExtensions.IndexedSegmentAt(System.String,System.Int32)">

            Gets the quoted three characters at the specified index of a string, including the index itself.

        </member>
        <member name="M:FluentAssertions.Common.StringExtensions.Escape(System.String)">

            Replaces all characters that might conflict with formatting placeholders and newlines with their escaped counterparts.

        </member>
        <member name="M:FluentAssertions.Common.StringExtensions.Combine(System.String,System.String,System.String)">

            Joins a string with one or more other strings using a specified separator.

            <remarks>
            Any string that is empty (including the original string) is ignored.
            </remarks>
        </member>
        <member name="M:FluentAssertions.Common.TypeExtensions.IsEquivalentTo(System.Reflection.PropertyInfo,System.Reflection.PropertyInfo)">

            Determines whether two <see cref="T:System.Reflection.PropertyInfo"/> objects refer to the same property.

        </member>
        <member name="M:FluentAssertions.Common.TypeExtensions.FindProperty(System.Type,System.String)">

            Finds the property by a case-sensitive name.

            <returns>
            Returns <c>null</c> if no such property exists.
            </returns>
        </member>
        <member name="M:FluentAssertions.Common.TypeExtensions.HasAttribute``1(System.Reflection.MethodInfo)">

            Determines whether the specified method has been annotated with a specific attribute.

            <returns>
              <c>true</c> if the specified method has attribute; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="T:FluentAssertions.EventMonitoringExtensions">

              Provides extension methods for monitoring and querying events.

        </member>
        <member name="M:FluentAssertions.EventMonitoringExtensions.MonitorEvents(System.Object)">

              Starts monitoring an object for its events.

            <exception cref="T:System.ArgumentNullException">Thrown if eventSource is Null.</exception>
        </member>
        <member name="M:FluentAssertions.EventMonitoringExtensions.ShouldRaise(System.Object,System.String)">

            Asserts that an object has raised a particular event at least once.

            <param name="eventSource">The object exposing the event.</param>
            <param name="eventName">The name of the event that should have been raised.</param>
            <returns></returns>
            <remarks>
            You must call <see cref="M:FluentAssertions.EventMonitoringExtensions.MonitorEvents(System.Object)"/> on the same object prior to this call so that Fluent Assertions can
            subscribe for the events of the object.
            </remarks>
        </member>
        <member name="M:FluentAssertions.EventMonitoringExtensions.ShouldRaise(System.Object,System.String,System.String,System.Object[])">

            Asserts that an object has raised a particular event at least once.

            <param name="eventSource">The object exposing the event.</param>
            <param name="eventName">
            The name of the event that should have been raised.
            </param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
            <remarks>
            You must call <see cref="M:FluentAssertions.EventMonitoringExtensions.MonitorEvents(System.Object)"/> on the same object prior to this call so that Fluent Assertions can
            subscribe for the events of the object.
            </remarks>
        </member>
        <member name="M:FluentAssertions.EventMonitoringExtensions.ShouldNotRaise(System.Object,System.String)">

            Asserts that an object has not raised a particular event.

            <param name="eventSource">The object exposing the event.</param>
            <param name="eventName">
            The name of the event that should not be raised.
            </param>
            <remarks>
            You must call <see cref="M:FluentAssertions.EventMonitoringExtensions.MonitorEvents(System.Object)"/> on the same object prior to this call so that Fluent Assertions can
            subscribe for the events of the object.
            </remarks>
        </member>
        <member name="M:FluentAssertions.EventMonitoringExtensions.ShouldNotRaise(System.Object,System.String,System.String,System.Object[])">

            Asserts that an object has not raised a particular event.

            <param name="eventSource">The object exposing the event.</param>
            <param name="eventName">
            The name of the event that should not be raised.
            </param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
            <remarks>
            You must call <see cref="M:FluentAssertions.EventMonitoringExtensions.MonitorEvents(System.Object)"/> on the same object prior to this call so that Fluent Assertions can
            subscribe for the events of the object.
            </remarks>
        </member>
        <member name="M:FluentAssertions.EventMonitoringExtensions.ShouldRaisePropertyChangeFor``1(``0,System.Linq.Expressions.Expression{System.Func{``0,System.Object}})">

            Asserts that an object has raised the <see cref="E:System.ComponentModel.INotifyPropertyChanged.PropertyChanged"/> event for a particular property.

            <remarks>
            You must call <see cref="M:FluentAssertions.EventMonitoringExtensions.MonitorEvents(System.Object)"/> on the same object prior to this call so that Fluent Assertions can
            subscribe for the events of the object.
            </remarks>
        </member>
        <member name="M:FluentAssertions.EventMonitoringExtensions.ShouldRaisePropertyChangeFor``1(``0,System.Linq.Expressions.Expression{System.Func{``0,System.Object}},System.String,System.Object[])">

            Asserts that an object has raised the <see cref="E:System.ComponentModel.INotifyPropertyChanged.PropertyChanged"/> event for a particular property.

            <param name="eventSource">The object exposing the event.</param>
            <param name="propertyExpression">
            A lambda expression referring to the property for which the property changed event should have been raised, or
            <c>null</c> to refer to all properties.
            </param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
            <remarks>
            You must call <see cref="M:FluentAssertions.EventMonitoringExtensions.MonitorEvents(System.Object)"/> on the same object prior to this call so that Fluent Assertions can
            subscribe for the events of the object.
            </remarks>
        </member>
        <member name="M:FluentAssertions.EventMonitoringExtensions.ShouldNotRaisePropertyChangeFor``1(``0,System.Linq.Expressions.Expression{System.Func{``0,System.Object}})">

            Asserts that an object has not raised the <see cref="E:System.ComponentModel.INotifyPropertyChanged.PropertyChanged"/> event for a particular property.

            <remarks>
            You must call <see cref="M:FluentAssertions.EventMonitoringExtensions.MonitorEvents(System.Object)"/> on the same object prior to this call so that Fluent Assertions can
            subscribe for the events of the object.
            </remarks>
        </member>
        <member name="M:FluentAssertions.EventMonitoringExtensions.ShouldNotRaisePropertyChangeFor``1(``0,System.Linq.Expressions.Expression{System.Func{``0,System.Object}},System.String,System.Object[])">

            Asserts that an object has not raised the <see cref="E:System.ComponentModel.INotifyPropertyChanged.PropertyChanged"/> event for a particular property.

            <param name="eventSource">The object exposing the event.</param>
            <param name="propertyExpression">
            A lambda expression referring to the property for which the property changed event should have been raised.
            </param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
            <remarks>
            You must call <see cref="M:FluentAssertions.EventMonitoringExtensions.MonitorEvents(System.Object)"/> on the same object prior to this call so that Fluent Assertions can
            subscribe for the events of the object.
            </remarks>
        </member>
        <member name="M:FluentAssertions.EventMonitoringExtensions.WithSender(FluentAssertions.Events.IEventRecorder,System.Object)">

            Asserts that all occurences of the event originated from the <param name="expectedSender"/>.

        </member>
        <member name="M:FluentAssertions.EventMonitoringExtensions.WithArgs``1(FluentAssertions.Events.IEventRecorder,System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})">

            Asserts that at least one occurrence of the event had an <see cref="T:System.EventArgs"/> object matching a predicate.

        </member>
        <member name="T:FluentAssertions.Events.EventHandlerFactory">

              Static methods that aid in generic event subscription

        </member>
        <member name="M:FluentAssertions.Events.EventHandlerFactory.GenerateHandler(System.Type,FluentAssertions.Events.IEventRecorder)">

              Generates an eventhandler for an event of type eventSignature that calls RegisterEvent on recorder
              when invoked.

        </member>
        <member name="M:FluentAssertions.Events.EventHandlerFactory.GetDelegateReturnType(System.Type)">

              Finds the Return Type of a Delegate.

        </member>
        <member name="M:FluentAssertions.Events.EventHandlerFactory.GetDelegateParameterTypes(System.Type)">

              Returns an Array of Types that make up a delegate's parameter signature.

        </member>
        <member name="M:FluentAssertions.Events.EventHandlerFactory.AppendParameterListThisReference(System.Type[])">

              Returns an array of types appended with an EventRecorder reference at the beginning.

        </member>
        <member name="M:FluentAssertions.Events.EventHandlerFactory.TypeIsDelegate(System.Type)">

              Returns T/F Dependent on a Type Being a Delegate.

        </member>
        <member name="M:FluentAssertions.Events.EventHandlerFactory.DelegateInvokeMethod(System.Type)">

              Returns the MethodInfo for the Delegate's "Invoke" Method.

        </member>
        <member name="T:FluentAssertions.Events.EventRecorder">

              Records activity for a single event.

        </member>
        <member name="T:FluentAssertions.Events.IEventRecorder">

              Records raised events for one event on one object

        </member>
        <member name="M:FluentAssertions.Events.IEventRecorder.RecordEvent(System.Object[])">

              Store information about a raised event

            <param name = "parameters">Parameters the event was raised with</param>
        </member>
        <member name="P:FluentAssertions.Events.IEventRecorder.EventObject">

              The object events are recorded from

        </member>
        <member name="P:FluentAssertions.Events.IEventRecorder.EventName">

              The name of the event that's recorded

        </member>
        <member name="M:FluentAssertions.Events.EventRecorder.#ctor(System.Object,System.String)">

            <param name = "eventRaiser">The object events are recorded from</param>
            <param name = "eventName">The name of the event that's recorded</param>
        </member>
        <member name="M:FluentAssertions.Events.EventRecorder.GetEnumerator">

              Enumerate raised events

        </member>
        <member name="M:FluentAssertions.Events.EventRecorder.System#Collections#IEnumerable#GetEnumerator">

              Enumerate raised events

            <returns></returns>
        </member>
        <member name="M:FluentAssertions.Events.EventRecorder.RecordEvent(System.Object[])">

              Called by the auto-generated IL, to record information about a raised event.

        </member>
        <member name="P:FluentAssertions.Events.EventRecorder.EventObject">

              The object events are recorded from

        </member>
        <member name="P:FluentAssertions.Events.EventRecorder.EventName">

              The name of the event that's recorded

        </member>
        <member name="T:FluentAssertions.Events.EventRecordersMap">

                Simple dictionary that uses a <see cref="T:System.WeakReference"/> to the event source as the key.
                This should ensure the Garbage Collector can still clean-up the event source object.

        </member>
        <member name="T:FluentAssertions.Events.RecordedEvent">

            This class is used to store data about an intercepted event

        </member>
        <member name="M:FluentAssertions.Events.RecordedEvent.#ctor(System.Object,System.Object[])">

            Default constructor stores the parameters the event was raised with

        </member>
        <member name="P:FluentAssertions.Events.RecordedEvent.Parameters">

            Parameters for the event

        </member>
        <member name="T:FluentAssertions.Execution.Execute">

            Helper class for verifying a condition and/or throwing a test harness specific exception representing an assertion failure.

        </member>
        <member name="P:FluentAssertions.Execution.Execute.Verification">

            Gets an object that wraps and executes a conditional or unconditional verification.

        </member>
        <member name="T:FluentAssertions.Execution.FallbackTestFramework">

            Throws a generic exception in case no other test harness is detected.

        </member>
        <member name="T:FluentAssertions.Execution.ITestFramework">

            Represents an abstraction of a particular test framework such as MSTest, nUnit, etc.

        </member>
        <member name="M:FluentAssertions.Execution.ITestFramework.Throw(System.String)">

            Throws a framework-specific exception to indicate a failing unit test.

        </member>
        <member name="P:FluentAssertions.Execution.ITestFramework.IsAvailable">

            Gets a value indicating whether the corresponding test framework is currently available.

        </member>
        <member name="M:FluentAssertions.Execution.FallbackTestFramework.Throw(System.String)">

            Throws a framework-specific exception to indicate a failing unit test.

        </member>
        <member name="P:FluentAssertions.Execution.FallbackTestFramework.IsAvailable">

            Gets a value indicating whether the corresponding test framework is currently available.

        </member>
        <member name="M:FluentAssertions.Execution.GallioTestFramework.Throw(System.String)">

            Throws a framework-specific exception to indicate a failing unit test.

        </member>
        <member name="P:FluentAssertions.Execution.GallioTestFramework.IsAvailable">

            Gets a value indicating whether the corresponding test framework is currently available.

        </member>
        <member name="T:FluentAssertions.Execution.Verification">

            Provides a fluent API for verifying an arbitrary condition.

        </member>
        <member name="F:FluentAssertions.Execution.Verification.ReasonTag">

            Represents the phrase that can be used in <see cref="M:FluentAssertions.Execution.Verification.FailWith(System.String,System.Object[])"/> as a placeholder for the reason of an assertion.

        </member>
        <member name="M:FluentAssertions.Execution.Verification.#ctor">

            Initializes a new instance of the <see cref="T:FluentAssertions.Execution.Verification"/> class.

        </member>
        <member name="M:FluentAssertions.Execution.Verification.SubjectNameOr(System.String)">

            Gets the name or identifier of the current subject, or a default value if the subject is not known.

        </member>
        <member name="M:FluentAssertions.Execution.Verification.ForCondition(System.Boolean)">

            Specify the condition that must be satisfied.

            <param name="condition">If <c>true</c> the verification will be succesful.</param>
        </member>
        <member name="M:FluentAssertions.Execution.Verification.ForCondition(System.Func{System.Boolean})">

            Specify a predicate that with the condition that must be satisfied.

        </member>
        <member name="M:FluentAssertions.Execution.Verification.BecauseOf(System.String,System.Object[])">

            Specify the reason why you expect the condition to be <c>true</c>.

            <param name="reason">
            A formatted phrase explaining why the condition should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Execution.Verification.FailWith(System.String,System.Object[])">

            Define the failure message for the verification.

            <remarks>
            If the <paramref name="failureMessage"/> contains the text "{reason}", this will be replaced by the reason as
            defined through <see cref="M:FluentAssertions.Execution.Verification.BecauseOf(System.String,System.Object[])"/>. Only 10 <paramref name="failureArgs"/> are supported in combination with
            a {reason}.
            </remarks>
            <param name="failureMessage">The format string that represents the failure message.</param>
            <param name="failureArgs">Optional arguments for the <paramref name="failureMessage"/></param>
        </member>
        <member name="P:FluentAssertions.Execution.Verification.UsingLineBreaks">

            Indicates that every argument passed into <see cref="M:FluentAssertions.Execution.Verification.FailWith(System.String,System.Object[])"/> is displayed on a separate line.

        </member>
        <member name="P:FluentAssertions.Execution.Verification.SubjectName">

            Gets or sets the name of the subject for the next verification.

        </member>
        <member name="T:FluentAssertions.FluentDateTimeExtensions">

            Extension methods on <see cref="T:System.Int32"/> to allow for a more fluent way of specifying a <see cref="T:System.DateTime"/>.

            <example>
            Instead of

            new DateTime(2011, 3, 10)

            you can write 3.March(2011)

            Or even

            3.March(2011).At(09, 30)
            </example>
            <seealso cref="T:FluentAssertions.TimeSpanConversionExtensions"/>
        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.January(System.Int32,System.Int32)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="day"/> and <paramref name="year"/>
            in the month January.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.February(System.Int32,System.Int32)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="day"/> and <paramref name="year"/>
            in the month February.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.March(System.Int32,System.Int32)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="day"/> and <paramref name="year"/>
            in the month March.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.April(System.Int32,System.Int32)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="day"/> and <paramref name="year"/>
            in the month April.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.May(System.Int32,System.Int32)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="day"/> and <paramref name="year"/>
            in the month May.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.June(System.Int32,System.Int32)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="day"/> and <paramref name="year"/>
            in the month June.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.July(System.Int32,System.Int32)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="day"/> and <paramref name="year"/>
            in the month July.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.August(System.Int32,System.Int32)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="day"/> and <paramref name="year"/>
            in the month August.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.September(System.Int32,System.Int32)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="day"/> and <paramref name="year"/>
            in the month September.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.October(System.Int32,System.Int32)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="day"/> and <paramref name="year"/>
            in the month October.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.November(System.Int32,System.Int32)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="day"/> and <paramref name="year"/>
            in the month November.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.December(System.Int32,System.Int32)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="day"/> and <paramref name="year"/>
            in the month December.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.At(System.DateTime,System.TimeSpan)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="date"/> and <paramref name="time"/>.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.At(System.DateTime,System.Int32,System.Int32,System.Int32,System.Int32)">

            Returns a new <see cref="T:System.DateTime"/> value for the specified <paramref name="date"/> and time with the specified
            <paramref name="hours"/>, <paramref name="minutes"/> and optionally <paramref name="seconds"/>.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.Before(System.TimeSpan,System.DateTime)">

            Returns a new <see cref="T:System.DateTime"/> value that is the current <see cref="T:System.TimeSpan"/> before the
            specified <paramref name="sourceDateTime"/>.

        </member>
        <member name="M:FluentAssertions.FluentDateTimeExtensions.After(System.TimeSpan,System.DateTime)">

            Returns a new <see cref="T:System.DateTime"/> value that is the current <see cref="T:System.TimeSpan"/> after the
            specified <paramref name="sourceDateTime"/>.

        </member>
        <member name="T:FluentAssertions.Formatting.AttributeBasedFormatter">

            Specialized value formatter that looks for static methods in the caller's assembly marked with the
            <see cref="T:FluentAssertions.Formatting.ValueFormatterAttribute"/>.

        </member>
        <member name="M:FluentAssertions.Formatting.IValueFormatter.CanHandle(System.Object)">

            Indicates whether the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified <paramref name="value"/>.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <returns>
            <c>true</c> if the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.IValueFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.AttributeBasedFormatter.CanHandle(System.Object)">

            Indicates whether the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified <paramref name="value"/>.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <returns>
            <c>true</c> if the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.AttributeBasedFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.DateTimeValueFormatter.CanHandle(System.Object)">

            Indicates whether the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified <paramref name="value"/>.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <returns>
            <c>true</c> if the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.DateTimeValueFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.DefaultValueFormatter.CanHandle(System.Object)">

              Determines whether this instance can handle the specified value.

            <param name = "value">The value.</param>
            <returns>
              <c>true</c> if this instance can handle the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.DefaultValueFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.EnumerableValueFormatter.CanHandle(System.Object)">

            Indicates whether the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified <paramref name="value"/>.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <returns>
            <c>true</c> if the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.EnumerableValueFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.ExpressionValueFormatter.CanHandle(System.Object)">

            Indicates whether the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified <paramref name="value"/>.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <returns>
            <c>true</c> if the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.ExpressionValueFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="T:FluentAssertions.Formatting.Formatter">

            Provides services for formatting an object being used in an assertion in a human readable format.

        </member>
        <member name="F:FluentAssertions.Formatting.Formatter.Formatters">

            A list of objects responsible for formatting the objects represented by placeholders.

        </member>
        <member name="M:FluentAssertions.Formatting.Formatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a human-readable representation of a particular object.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="nestedPropertyLevel">
                The level of nesting for the supplied value. This is used for indenting the format string for objects that have
                no <see cref="M:System.Object.ToString"/> override.
            </param>
            <param name="useLineBreaks">
            Indicates whether the formatter should use line breaks when the specific <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> supports it.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.GuidValueFormatter.CanHandle(System.Object)">

            Indicates whether the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified <paramref name="value"/>.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <returns>
            <c>true</c> if the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.GuidValueFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.NullValueFormatter.CanHandle(System.Object)">

            Indicates whether the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified <paramref name="value"/>.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <returns>
            <c>true</c> if the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.NullValueFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.NumericValueFormatter.CanHandle(System.Object)">

            Indicates whether the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified <paramref name="value"/>.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <returns>
            <c>true</c> if the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.NumericValueFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.StringValueFormatter.CanHandle(System.Object)">

            Indicates whether the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified <paramref name="value"/>.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <returns>
            <c>true</c> if the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.StringValueFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.TimeSpanValueFormatter.CanHandle(System.Object)">

            Indicates whether the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified <paramref name="value"/>.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <returns>
            <c>true</c> if the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.TimeSpanValueFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="T:FluentAssertions.Formatting.ValueFormatterAttribute">

            Marks a static method as a kind of <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> for a particular type.

        </member>
        <member name="M:FluentAssertions.Formatting.XAttributeValueFormatter.CanHandle(System.Object)">

            Indicates whether the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified <paramref name="value"/>.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <returns>
            <c>true</c> if the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.XAttributeValueFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.XDocumentValueFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.XElementValueFormatter.CanHandle(System.Object)">

            Indicates whether the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified <paramref name="value"/>.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <returns>
            <c>true</c> if the current <see cref="T:FluentAssertions.Formatting.IValueFormatter"/> can handle the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:FluentAssertions.Formatting.XElementValueFormatter.ToString(System.Object,System.Boolean,System.Collections.Generic.IList{System.Object},System.Int32)">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <param name="value">The value for which to create a <see cref="T:System.String"/>.</param>
            <param name="useLineBreaks"> </param>
            <param name="processedObjects">
            A collection of objects that
            </param>
            <param name="nestedPropertyLevel">
            The level of nesting for the supplied value. This is used for indenting the format string for objects that have
            no <see cref="M:System.Object.ToString"/> override.
            </param>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="T:FluentAssertions.NumericAssertionsExtensions">

            Contains a number of extension methods for floating point <see cref="T:FluentAssertions.Numeric.NumericAssertions`1"/>.

        </member>
        <member name="M:FluentAssertions.NumericAssertionsExtensions.BeApproximately(FluentAssertions.Numeric.NullableNumericAssertions{System.Single},System.Single,System.Single,System.String,System.Object[])">

            Asserts a floating point value approximates another value as close as possible.

            <param name="parent">The <see cref="T:FluentAssertions.Numeric.NumericAssertions`1"/> object that is being extended.</param>
            <param name="expectedValue">
            The expected value to compare the actual value with.
            </param>
            <param name="precision">
            The maximum amount of which the two values may differ.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.NumericAssertionsExtensions.BeApproximately(FluentAssertions.Numeric.NumericAssertions{System.Single},System.Single,System.Single,System.String,System.Object[])">

            Asserts a floating point value approximates another value as close as possible.

            <param name="parent">The <see cref="T:FluentAssertions.Numeric.NumericAssertions`1"/> object that is being extended.</param>
            <param name="expectedValue">
            The expected value to compare the actual value with.
            </param>
            <param name="precision">
            The maximum amount of which the two values may differ.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.NumericAssertionsExtensions.BeApproximately(FluentAssertions.Numeric.NullableNumericAssertions{System.Double},System.Double,System.Double,System.String,System.Object[])">

            Asserts a floating point value approximates another value as close as possible.

            <param name="parent">The <see cref="T:FluentAssertions.Numeric.NumericAssertions`1"/> object that is being extended.</param>
            <param name="expectedValue">
            The expected value to compare the actual value with.
            </param>
            <param name="precision">
            The maximum amount of which the two values may differ.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.NumericAssertionsExtensions.BeApproximately(FluentAssertions.Numeric.NumericAssertions{System.Double},System.Double,System.Double,System.String,System.Object[])">

            Asserts a floating point value approximates another value as close as possible.

            <param name="parent">The <see cref="T:FluentAssertions.Numeric.NumericAssertions`1"/> object that is being extended.</param>
            <param name="expectedValue">
            The expected value to compare the actual value with.
            </param>
            <param name="precision">
            The maximum amount of which the two values may differ.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="T:FluentAssertions.Numeric.ComparableTypeAssertions`1">

            Contains a number of methods to assert that an <see cref="T:System.IComparable`1"/> is in the expected state.

        </member>
        <member name="M:FluentAssertions.Numeric.ComparableTypeAssertions`1.Be(`0,System.String,System.Object[])">

            Asserts that the subject is considered equal to another object according to the implementation of <see cref="T:System.IComparable`1"/>.

            <param name="expected">
            The object to pass to the subject's <see cref="M:System.IComparable`1.CompareTo(`0)"/> method.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.ComparableTypeAssertions`1.NotBe(`0,System.String,System.Object[])">

            Asserts that the subject is not equal to another object according to its implementation of <see cref="T:System.IComparable`1"/>.

            <param name="expected">
            The object to pass to the subject's <see cref="M:System.IComparable`1.CompareTo(`0)"/> method.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.ComparableTypeAssertions`1.BeLessThan(`0,System.String,System.Object[])">

            Asserts that the subject is less than another object according to its implementation of <see cref="T:System.IComparable`1"/>.

            <param name="expected">
            The object to pass to the subject's <see cref="M:System.IComparable`1.CompareTo(`0)"/> method.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.ComparableTypeAssertions`1.BeLessOrEqualTo(`0,System.String,System.Object[])">

            Asserts that the subject is less than or equal to another object according to its implementation of <see cref="T:System.IComparable`1"/>.

            <param name="expected">
            The object to pass to the subject's <see cref="M:System.IComparable`1.CompareTo(`0)"/> method.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.ComparableTypeAssertions`1.BeGreaterThan(`0,System.String,System.Object[])">

            Asserts that the subject is greater than another object according to its implementation of <see cref="T:System.IComparable`1"/>.

            <param name="expected">
            The object to pass to the subject's <see cref="M:System.IComparable`1.CompareTo(`0)"/> method.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.ComparableTypeAssertions`1.BeGreaterOrEqualTo(`0,System.String,System.Object[])">

            Asserts that the subject is greater than or equal to another object according to its implementation of <see cref="T:System.IComparable`1"/>.

            <param name="expected">
            The object to pass to the subject's <see cref="M:System.IComparable`1.CompareTo(`0)"/> method.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.ComparableTypeAssertions`1.BeInRange(`0,`0,System.String,System.Object[])">

            Asserts that a value is within a range.

            <remarks>
            Where the range is continuous or incremental depends on the actual type of the value.
            </remarks>
            <param name="minimumValue">
            The minimum valid value of the range.
            </param>
            <param name="maximumValue">
            The maximum valid value of the range.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.ComparableTypeAssertions`1.NotBeNull(System.String,System.Object[])">

            Asserts that a nullable numeric value is not <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.ComparableTypeAssertions`1.BeNull(System.String,System.Object[])">

            Asserts that a nullable numeric value is <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Numeric.ComparableTypeAssertions`1.Subject">

            Gets the object which value is being asserted.

        </member>
        <member name="T:FluentAssertions.Numeric.NumericAssertions`1">

            Contains a number of methods to assert that an <see cref="T:System.IComparable"/> is in the expected state.

        </member>
        <member name="M:FluentAssertions.Numeric.NumericAssertions`1.Be(`0,System.String,System.Object[])">

            Asserts that the integral number value is exactly the same as the <paramref name="expected"/> value.

            <param name="expected">The expected value.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NumericAssertions`1.Be(System.Nullable{`0},System.String,System.Object[])">

            Asserts that the integral number value is exactly the same as the <paramref name="expected"/> value.

            <param name="expected">The expected value.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NumericAssertions`1.NotBe(`0,System.String,System.Object[])">

            Asserts that the integral number value is not the same as the <paramref name="unexpected"/> value.

            <param name="unexpected">The unexpected value.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NumericAssertions`1.NotBe(System.Nullable{`0},System.String,System.Object[])">

            Asserts that the integral number value is not the same as the <paramref name="unexpected"/> value.

            <param name="unexpected">The unexpected value.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NumericAssertions`1.BePositive(System.String,System.Object[])">

            Asserts that the numeric value is greater than or equal to zero.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NumericAssertions`1.BeNegative(System.String,System.Object[])">

            Asserts that the numeric value is less than zero.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NumericAssertions`1.BeLessThan(`0,System.String,System.Object[])">

            Asserts that the numeric value is less than the specified <paramref name="expected"/> value.

            <param name="expected">The value to compare the current numeric value with.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NumericAssertions`1.BeLessOrEqualTo(`0,System.String,System.Object[])">

            Asserts that the numeric value is less than or equal to the specified <paramref name="expected"/> value.

            <param name="expected">The value to compare the current numeric value with.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NumericAssertions`1.BeGreaterThan(`0,System.String,System.Object[])">

            Asserts that the numeric value is greater than the specified <paramref name="expected"/> value.

            <param name="expected">The value to compare the current numeric value with.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NumericAssertions`1.BeGreaterOrEqualTo(`0,System.String,System.Object[])">

            Asserts that the numeric value is greater than or equal to the specified <paramref name="expected"/> value.

            <param name="expected">The value to compare the current numeric value with.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NumericAssertions`1.BeInRange(`0,`0,System.String,System.Object[])">

            Asserts that a value is within a range.

            <remarks>
            Where the range is continuous or incremental depends on the actual type of the value.
            </remarks>
            <param name="minimumValue">
            The minimum valid value of the range.
            </param>
            <param name="maximumValue">
            The maximum valid value of the range.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NumericAssertions`1.BeOneOf(`0[])">

            Asserts that a value is one of the specified <paramref name="validValues"/>.

            <param name="validValues">
            The values that are valid.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NumericAssertions`1.BeOneOf(System.Collections.Generic.IEnumerable{`0},System.String,System.Object[])">

            Asserts that a value is one of the specified <paramref name="validValues"/>.

            <param name="validValues">
            The values that are valid.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NullableNumericAssertions`1.HaveValue(System.String,System.Object[])">

            Asserts that a nullable numeric value is not <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Numeric.NullableNumericAssertions`1.NotHaveValue(System.String,System.Object[])">

            Asserts that a nullable numeric value is <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="T:FluentAssertions.Primitives.BooleanAssertions">

            Contains a number of methods to assert that a <see cref="T:System.Boolean"/> is in the expected state.

        </member>
        <member name="M:FluentAssertions.Primitives.BooleanAssertions.BeFalse(System.String,System.Object[])">

            Asserts that the value is <c>false</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.BooleanAssertions.BeTrue(System.String,System.Object[])">

            Asserts that the value is <c>true</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.BooleanAssertions.Be(System.Boolean,System.String,System.Object[])">

            Asserts that the value is equal to the specified <paramref name="expected"/> value.

            <param name="expected">The expected value</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Primitives.BooleanAssertions.Subject">

            Gets the object which value is being asserted.

        </member>
        <member name="T:FluentAssertions.ComparisonMode">

            Defines the way <see cref="!:ExceptionAssertions<TException>.WithMessage(string)"/> compares the expected exception
            message with the actual one.

        </member>
        <member name="F:FluentAssertions.ComparisonMode.Exact">

            The message must match exactly, including the casing of the characters.

        </member>
        <member name="F:FluentAssertions.ComparisonMode.Equivalent">

            The message must match except for the casing of the characters.

        </member>
        <member name="F:FluentAssertions.ComparisonMode.StartWith">

            The message must start with the exact text, including the casing of the characters..

        </member>
        <member name="F:FluentAssertions.ComparisonMode.StartWithEquivalent">

            The message must start with the text except for the casing of the characters.

        </member>
        <member name="F:FluentAssertions.ComparisonMode.Substring">

            The message must contain the exact text.

        </member>
        <member name="F:FluentAssertions.ComparisonMode.EquivalentSubstring">

            The message must contain the text except for the casing of the characters.

        </member>
        <member name="F:FluentAssertions.ComparisonMode.Wildcard">

            The message must match a wildcard pattern consisting of ordinary characters as well as * and ?.

        </member>
        <member name="T:FluentAssertions.Primitives.DateTimeAssertions">

            Contains a number of methods to assert that a <see cref="T:System.DateTime"/> is in the expected state.

            <remarks>
            You can use the <see cref="T:FluentAssertions.FluentDateTimeExtensions"/> for a more fluent way of specifying a <see cref="T:System.DateTime"/>.
            </remarks>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.Be(System.DateTime,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.DateTime"/> is exactly equal to the <paramref name="expected"/> value.

            <param name="expected">The expected value</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.NotBe(System.DateTime,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.DateTime"/> is not equal to the <paramref name="unexpected"/> value.

            <param name="unexpected">The unexpected value</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.BeCloseTo(System.DateTime,System.Int32,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.DateTime"/> is within the specified number of milliseconds (default = 20 ms)
            from the specified <paramref name="nearbyTime"/> value.

            <remarks>
            Use this assertion when, for example the database truncates datetimes to nearest 20ms. If you want to assert to the exact datetime,
            use <see cref="M:FluentAssertions.Primitives.DateTimeAssertions.Be(System.DateTime,System.String,System.Object[])"/>.
            </remarks>
            <param name="nearbyTime">
            The expected time to compare the actual value with.
            </param>
            <param name="precision">
            The maximum amount of milliseconds which the two values may differ.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.BeBefore(System.DateTime,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.DateTime"/> is before the specified value.

            <param name="expected">The <see cref="T:System.DateTime"/> that the current value is expected to be before.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.BeOnOrBefore(System.DateTime,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.DateTime"/> is either on, or before the specified value.

            <param name="expected">The <see cref="T:System.DateTime"/> that the current value is expected to be on or before.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.BeAfter(System.DateTime,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.DateTime"/> is after the specified value.

            <param name="expected">The <see cref="T:System.DateTime"/> that the current value is expected to be after.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.BeOnOrAfter(System.DateTime,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.DateTime"/> is either on, or after the specified value.

            <param name="expected">The <see cref="T:System.DateTime"/> that the current value is expected to be on or after.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.HaveYear(System.Int32,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.DateTime"/> has the <paramref name="expected"/> year.

            <param name="expected">The expected year of the current value.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.HaveMonth(System.Int32,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.DateTime"/> has the <paramref name="expected"/> month.

            <param name="expected">The expected month of the current value.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.HaveDay(System.Int32,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.DateTime"/> has the <paramref name="expected"/> day.

            <param name="expected">The expected day of the current value.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.HaveHour(System.Int32,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.DateTime"/> has the <paramref name="expected"/> hour.

            <param name="expected">The expected hour of the current value.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.HaveMinute(System.Int32,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.DateTime"/> has the <paramref name="expected"/> minute.

            <param name="expected">The expected minutes of the current value.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.HaveSecond(System.Int32,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.DateTime"/> has the <paramref name="expected"/> second.

            <param name="expected">The expected seconds of the current value.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.BeMoreThan(System.TimeSpan)">

            Returns a <see cref="T:FluentAssertions.Primitives.TimeSpanAssertions"/> object that can be used to assert that the current <see cref="T:System.DateTime"/>
            exceeds the specified <paramref name="timeSpan"/> compared to another <see cref="T:System.DateTime"/>.

            <param name="timeSpan">
            The amount of time that the current <see cref="T:System.DateTime"/> should exceed compared to another <see cref="T:System.DateTime"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.BeAtLeast(System.TimeSpan)">

            Returns a <see cref="T:FluentAssertions.Primitives.TimeSpanAssertions"/> object that can be used to assert that the current <see cref="T:System.DateTime"/>
            is equal to or exceeds the specified <paramref name="timeSpan"/> compared to another <see cref="T:System.DateTime"/>.

            <param name="timeSpan">
            The amount of time that the current <see cref="T:System.DateTime"/> should be equal or exceed compared to
            another <see cref="T:System.DateTime"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.BeExactly(System.TimeSpan)">

            Returns a <see cref="T:FluentAssertions.Primitives.TimeSpanAssertions"/> object that can be used to assert that the current <see cref="T:System.DateTime"/>
            differs exactly the specified <paramref name="timeSpan"/> compared to another <see cref="T:System.DateTime"/>.

            <param name="timeSpan">
            The amount of time that the current <see cref="T:System.DateTime"/> should differ exactly compared to another <see cref="T:System.DateTime"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.BeWithin(System.TimeSpan)">

            Returns a <see cref="T:FluentAssertions.Primitives.TimeSpanAssertions"/> object that can be used to assert that the current <see cref="T:System.DateTime"/>
            is within the specified <paramref name="timeSpan"/> compared to another <see cref="T:System.DateTime"/>.

            <param name="timeSpan">
            The amount of time that the current <see cref="T:System.DateTime"/> should be within another <see cref="T:System.DateTime"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.DateTimeAssertions.BeLessThan(System.TimeSpan)">

            Returns a <see cref="T:FluentAssertions.Primitives.TimeSpanAssertions"/> object that can be used to assert that the current <see cref="T:System.DateTime"/>
            differs at maximum the specified <paramref name="timeSpan"/> compared to another <see cref="T:System.DateTime"/>.

            <param name="timeSpan">
            The maximum amount of time that the current <see cref="T:System.DateTime"/> should differ compared to another <see cref="T:System.DateTime"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Primitives.DateTimeAssertions.Subject">

            Gets the object which value is being asserted.

        </member>
        <member name="T:FluentAssertions.Primitives.GuidAssertions">

            Contains a number of methods to assert that a <see cref="T:System.Guid"/> is in the correct state.

        </member>
        <member name="M:FluentAssertions.Primitives.GuidAssertions.BeEmpty(System.String,System.Object[])">

            Asserts that the <see cref="T:System.Guid"/> is <see cref="F:System.Guid.Empty"/>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.GuidAssertions.NotBeEmpty(System.String,System.Object[])">

            Asserts that the <see cref="T:System.Guid"/> is not <see cref="F:System.Guid.Empty"/>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.GuidAssertions.Be(System.String,System.String,System.Object[])">

            Asserts that the <see cref="T:System.Guid"/> is equal to the <paramref name="expected"/> GUID.

            <param name="expected">The expected <see cref="T:System.String"/> value to compare the actual value with.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.GuidAssertions.Be(System.Guid,System.String,System.Object[])">

            Asserts that the <see cref="T:System.Guid"/> is equal to the <paramref name="expected"/> GUID.

            <param name="expected">The expected value to compare the actual value with.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.GuidAssertions.NotBe(System.Guid,System.String,System.Object[])">

            Asserts that the <see cref="T:System.Guid"/> is not equal to the <paramref name="unexpected"/> GUID.

            <param name="unexpected">The unexpected value to compare the actual value with.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Primitives.GuidAssertions.Subject">

            Gets the object which value is being asserted.

        </member>
        <member name="T:FluentAssertions.Primitives.NullableBooleanAssertions">

            Contains a number of methods to assert that a nullable <see cref="T:System.Boolean"/> is in the expected state.

        </member>
        <member name="M:FluentAssertions.Primitives.NullableBooleanAssertions.HaveValue(System.String,System.Object[])">

            Asserts that a nullable boolean value is not <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.NullableBooleanAssertions.NotHaveValue(System.String,System.Object[])">

            Asserts that a nullable boolean value is <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.NullableBooleanAssertions.Be(System.Nullable{System.Boolean},System.String,System.Object[])">

            Asserts that the value is equal to the specified <paramref name="expected"/> value.

            <param name="expected">The expected value</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="T:FluentAssertions.Primitives.NullableDateTimeAssertions">

            Contains a number of methods to assert that a nullable <see cref="T:System.DateTime"/> is in the expected state.

            <remarks>
            You can use the <see cref="T:FluentAssertions.FluentDateTimeExtensions"/> for a more fluent way of specifying a <see cref="T:System.DateTime"/>.
            </remarks>
        </member>
        <member name="M:FluentAssertions.Primitives.NullableDateTimeAssertions.HaveValue(System.String,System.Object[])">

            Asserts that a nullable <see cref="T:System.DateTime"/> value is not <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.NullableDateTimeAssertions.NotHaveValue(System.String,System.Object[])">

            Asserts that a nullable <see cref="T:System.DateTime"/> value is <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.NullableDateTimeAssertions.Be(System.Nullable{System.DateTime},System.String,System.Object[])">

            Asserts that the value is equal to the specified <paramref name="expected"/> value.

            <param name="expected">The expected value</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="T:FluentAssertions.Primitives.NullableGuidAssertions">

            Contains a number of methods to assert that a nullable <see cref="T:System.Guid"/> is in the expected state.

        </member>
        <member name="M:FluentAssertions.Primitives.NullableGuidAssertions.HaveValue(System.String,System.Object[])">

            Asserts that a nullable <see cref="T:System.Guid"/> value is not <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.NullableGuidAssertions.NotHaveValue(System.String,System.Object[])">

            Asserts that a nullable <see cref="T:System.Guid"/> value is <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.NullableGuidAssertions.Be(System.Nullable{System.Guid},System.String,System.Object[])">

            Asserts that the value is equal to the specified <paramref name="expected"/> value.

            <param name="expected">The expected value</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="T:FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions">

            Contains a number of methods to assert that a nullable <see cref="T:System.TimeSpan"/> is in the expected state.

            <remarks>
            You can use the <see cref="T:FluentAssertions.TimeSpanConversionExtensions"/> for a more fluent way of specifying a <see cref="T:System.TimeSpan"/>.
            </remarks>
        </member>
        <member name="T:FluentAssertions.Primitives.SimpleTimeSpanAssertions">

            Contains a number of methods to assert that a nullable <see cref="T:System.TimeSpan"/> is in the expected state.

        </member>
        <member name="M:FluentAssertions.Primitives.SimpleTimeSpanAssertions.BePositive(System.String,System.Object[])">

            Asserts that the time difference of the current <see cref="T:System.TimeSpan"/> is greater than zero.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.SimpleTimeSpanAssertions.BeNegative(System.String,System.Object[])">

            Asserts that the time difference of the current <see cref="T:System.TimeSpan"/> is less than zero.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.SimpleTimeSpanAssertions.Be(System.TimeSpan,System.String,System.Object[])">

            Asserts that the time difference of the current <see cref="T:System.TimeSpan"/> is equal to the
            specified <paramref name="expected"/> time.

            <param name="expected">The expected time difference</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.SimpleTimeSpanAssertions.NotBe(System.TimeSpan,System.String,System.Object[])">

            Asserts that the time difference of the current <see cref="T:System.TimeSpan"/> is not equal to the
            specified <paramref name="unexpected"/> time.

            <param name="unexpected">The unexpected time difference</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.SimpleTimeSpanAssertions.BeLessThan(System.TimeSpan,System.String,System.Object[])">

            Asserts that the time difference of the current <see cref="T:System.TimeSpan"/> is less than the
            specified <paramref name="expected"/> time.

            <param name="expected">The time difference to which the current value will be compared</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.SimpleTimeSpanAssertions.BeLessOrEqualTo(System.TimeSpan,System.String,System.Object[])">

            Asserts that the time difference of the current <see cref="T:System.TimeSpan"/> is less than or equal to the
            specified <paramref name="expected"/> time.

            <param name="expected">The time difference to which the current value will be compared</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.SimpleTimeSpanAssertions.BeGreaterThan(System.TimeSpan,System.String,System.Object[])">

            Asserts that the time difference of the current <see cref="T:System.TimeSpan"/> is greater than the
            specified <paramref name="expected"/> time.

            <param name="expected">The time difference to which the current value will be compared</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.SimpleTimeSpanAssertions.BeGreaterOrEqualTo(System.TimeSpan,System.String,System.Object[])">

            Asserts that the time difference of the current <see cref="T:System.TimeSpan"/> is greater than or equal to the
            specified <paramref name="expected"/> time.

            <param name="expected">The time difference to which the current value will be compared</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Primitives.SimpleTimeSpanAssertions.Subject">

            Gets the object which value is being asserted.

        </member>
        <member name="M:FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions.HaveValue(System.String,System.Object[])">

            Asserts that a nullable <see cref="T:System.TimeSpan"/> value is not <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions.NotHaveValue(System.String,System.Object[])">

            Asserts that a nullable <see cref="T:System.TimeSpan"/> value is <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="T:FluentAssertions.Primitives.ObjectAssertions">

            Contains a number of methods to assert that an <see cref="T:System.Object"/> is in the expected state.

        </member>
        <member name="M:FluentAssertions.Primitives.ObjectAssertions.Be(System.Object,System.String,System.Object[])">

            Asserts that an object equals another object using its <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">The expected value</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.ObjectAssertions.NotBe(System.Object,System.String,System.Object[])">

            Asserts that an object does not equal another object using it's <see cref="M:System.Object.Equals(System.Object)"/> method.

            <param name="unexpected">The unexpected value</param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.ObjectAssertions.BeSameAs(System.Object,System.String,System.Object[])">

            Asserts that an object reference refers to the exact same object as another object reference.

            <param name="expected">The expected object</param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.ObjectAssertions.NotBeSameAs(System.Object,System.String,System.Object[])">

            Asserts that an object reference refers to a different object than another object reference refers to.

            <param name="unexpected">The unexpected object</param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.ObjectAssertions.BeNull(System.String,System.Object[])">

            Asserts that the object is <c>null</c>.

            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.ObjectAssertions.NotBeNull(System.String,System.Object[])">

            Asserts that the object is not <c>null</c>.

            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.ObjectAssertions.BeBinarySerializable(System.String,System.Object[])">

            Asserts that an object can be serialized and deserialized using the binary serializer and that it stills retains
            the values of all properties.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.ObjectAssertions.BeXmlSerializable(System.String,System.Object[])">

            Asserts that an object can be serialized and deserialized using the XML serializer and that it stills retains
            the values of all properties.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="T:FluentAssertions.Primitives.StringAssertions">

            Contains a number of methods to assert that a <see cref="T:System.String"/> is in the expected state.

        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.#ctor(System.String)">

            Initializes a new instance of the <see cref="T:System.Object" /> class.

        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.Be(System.String,System.String,System.Object[])">

            Asserts that a string is exactly the same as another string, including the casing and any leading or trailing whitespace.

            <param name="expected">The expected string.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.BeOneOf(System.String[])">

            Asserts that the <see cref="T:System.String"/> is one of the specified <paramref name="validValues"/>.

            <param name="validValues">
            The values that are valid.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.BeOneOf(System.Collections.Generic.IEnumerable{System.String},System.String,System.Object[])">

            Asserts that the <see cref="T:System.String"/> is one of the specified <paramref name="validValues"/>.

            <param name="validValues">
            The values that are valid.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.BeEquivalentTo(System.String,System.String,System.Object[])">

            Asserts that a string is exactly the same as another string, including any leading or trailing whitespace, with
            the exception of the casing.

            <param name="expected">
            The string that the subject is expected to be equivalent to.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.NotBe(System.String,System.String,System.Object[])">

            Asserts that a string is not exactly the same as the specified <paramref name="unexpected"/>,
            including any leading or trailing whitespace, with the exception of the casing.

            <param name="unexpected">The string that the subject is not expected to be equivalent to.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.Match(System.String,System.String,System.Object[])">

            Asserts that a string matches a wildcard pattern.

            <param name="wildcardPattern">
            The wildcard pattern with which the subject is matched, where * and ? have special meanings.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.NotMatch(System.String,System.String,System.Object[])">

            Asserts that a string does not match a wildcard pattern.

            <param name="wildcardPattern">
            The wildcard pattern with which the subject is matched, where * and ? have special meanings.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.MatchEquivalentOf(System.String,System.String,System.Object[])">

            Asserts that a string matches a wildcard pattern.

            <param name="wildcardPattern">
            The wildcard pattern with which the subject is matched, where * and ? have special meanings.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.NotMatchEquivalentOf(System.String,System.String,System.Object[])">

            Asserts that a string does not match a wildcard pattern.

            <param name="wildcardPattern">
            The wildcard pattern with which the subject is matched, where * and ? have special meanings.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.StartWith(System.String,System.String,System.Object[])">

            Asserts that a string starts exactly with the specified <paramref name="expected"/> value,
            including the casing and any leading or trailing whitespace.

            <param name="expected">The string that the subject is expected to start with.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.StartWithEquivalent(System.String,System.String,System.Object[])">

            Asserts that a string starts with the specified <paramref name="expected"/>,
            including any leading or trailing whitespace, with the exception of the casing.

            <param name="expected">The string that the subject is expected to start with.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.EndWith(System.String,System.String,System.Object[])">

            Asserts that a string ends exactly with the specified <paramref name="expected"/>,
            including the casing and any leading or trailing whitespace.

            <param name="expected">The string that the subject is expected to end with.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.EndWithEquivalent(System.String,System.String,System.Object[])">

            Asserts that a string ends with the specified <paramref name="expected"/>,
            including any leading or trailing whitespace, with the exception of the casing.

            <param name="expected">The string that the subject is expected to end with.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.Contain(System.String,System.String,System.Object[])">

            Asserts that a string contains another (fragment of a) string.

            <param name="expected">
            The (fragement of a) string that the current string should contain.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.ContainEquivalentOf(System.String,System.String,System.Object[])">

            Asserts that a string contains the specified <paramref name="expected"/>,
            including any leading or trailing whitespace, with the exception of the casing.

            <param name="expected">The string that the subject is expected to contain.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.NotContain(System.String,System.String,System.Object[])">

            Asserts that a string does not contain another (fragment of a) string.

            <param name="expected">
            The (fragement of a) string that the current string should not contain.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.NotContainEquivalentOf(System.String,System.String,System.Object[])">

            Asserts that a string does not contain the specified <paramref name="unexpected"/> string,
            including any leading or trailing whitespace, with the exception of the casing.

            <param name="unexpected">The string that the subject is not expected to contain.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.BeEmpty(System.String,System.Object[])">

            Asserts that a string is <see cref="F:System.String.Empty"/>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.NotBeEmpty(System.String,System.Object[])">

            Asserts that a string is not <see cref="F:System.String.Empty"/>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.HaveLength(System.Int32,System.String,System.Object[])">

            Asserts that a string has the specified <paramref name="expected"/> length.

            <param name="expected">The expected length of the string</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.BeNull(System.String,System.Object[])">

            Asserts that a string is <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.NotBeNull(System.String,System.Object[])">

            Asserts that a string is not <c>null</c>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.NotBeNullOrEmpty(System.String,System.Object[])">

            Asserts that a string is neither <c>null</c> nor <see cref="F:System.String.Empty"/>.

            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.BeNullOrEmpty(System.String,System.Object[])">

            Asserts that a string is either <c>null</c> or <see cref="F:System.String.Empty"/>.

            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.NotBeBlank(System.String,System.Object[])">

            Asserts that a string is neither <c>null</c> nor <see cref="F:System.String.Empty"/> nor white space

            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.StringAssertions.BeBlank(System.String,System.Object[])">

            Asserts that a string is either <c>null</c> or <see cref="F:System.String.Empty"/> or white space

            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="P:FluentAssertions.Primitives.StringAssertions.Subject">

            Gets the object which value is being asserted.

        </member>
        <member name="T:FluentAssertions.Primitives.StringValidator">

            Dedicated class for comparing two strings and generating consistent error messages.

        </member>
        <member name="P:FluentAssertions.Primitives.StringWildcardMatchingValidator.Negate">

            Gets or sets a value indicating whether the subject should not match the pattern.

        </member>
        <member name="P:FluentAssertions.Primitives.StringWildcardMatchingValidator.IgnoreCase">

            Gets or sets a value indicating whether the matching process should ignore any casing difference.

        </member>
        <member name="T:FluentAssertions.Primitives.TimeSpanAssertions">

            Contains a number of methods to assert that two <see cref="T:System.DateTime"/> objects differ in the expected way.

            <remarks>
            You can use the <see cref="T:FluentAssertions.FluentDateTimeExtensions"/> and <see cref="T:FluentAssertions.TimeSpanConversionExtensions"/> for a more fluent
            way of specifying a <see cref="T:System.DateTime"/> or a <see cref="T:System.TimeSpan"/>.
            </remarks>
        </member>
        <member name="M:FluentAssertions.Primitives.TimeSpanAssertions.Before(System.DateTime,System.String,System.Object[])">

            Asserts that a <see cref="T:System.DateTime"/> occurs a specified amount of time before another <see cref="T:System.DateTime"/>.

            <param name="target">
            The <see cref="T:System.DateTime"/> to compare the subject with.
            </param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Primitives.TimeSpanAssertions.After(System.DateTime,System.String,System.Object[])">

            Asserts that a <see cref="T:System.DateTime"/> occurs a specified amount of time after another <see cref="T:System.DateTime"/>.

            <param name="target">
            The <see cref="T:System.DateTime"/> to compare the subject with.
            </param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="T:FluentAssertions.Primitives.TimeSpanAssertions.TimeSpanPredicate">

            Provides the logic and the display text for a <see cref="T:FluentAssertions.Primitives.TimeSpanCondition"/>.

        </member>
        <member name="T:FluentAssertions.Specialized.ActionAssertions">

            Contains a number of methods to assert that an <see cref="T:System.Action"/> yields the expected result.

        </member>
        <member name="M:FluentAssertions.Specialized.ActionAssertions.ShouldThrow``1(System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Action"/> throws an exception of type <typeparamref name="TException"/>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Specialized.ActionAssertions.ShouldNotThrow``1(System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Action"/> does not throw an exception of type <typeparamref name="TException"/>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Specialized.ActionAssertions.ShouldNotThrow(System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Action"/> does not throw any exception.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Specialized.ActionAssertions.Subject">

            Gets the <see cref="T:System.Action"/> that is being asserted.

        </member>
        <member name="T:FluentAssertions.Specialized.ExceptionAssertions`1">

              Contains a number of methods to assert that an <see cref="T:System.Exception"/> is in the correct state.

        </member>
        <member name="M:FluentAssertions.Specialized.ExceptionAssertions`1.WithMessage(System.String,System.String,System.Object[])">

              Asserts that the thrown exception has a message that matches <paramref name="expectedMessage"/>
              depending on the specified matching mode.

            <param name="expectedMessage">
              The expected message of the exception.
            </param>
            <param name="reason">
              A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
              is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
              Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Specialized.ExceptionAssertions`1.WithMessage(System.String,FluentAssertions.ComparisonMode,System.String,System.Object[])">

              Asserts that the thrown exception has a message that matches <paramref name="expectedMessage"/>
              depending on the specified matching mode.

            <param name="expectedMessage">
              The expected message of the exception.
            </param>
            <param name="comparisonMode">
              Determines how the expected message is compared with the actual message.
            </param>
            <param name="reason">
              A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
              is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
              Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Specialized.ExceptionAssertions`1.WithInnerException``1">

              Asserts that the thrown exception contains an inner exception of type <typeparamref name = "TInnerException" />.

            <typeparam name = "TInnerException">The expected type of the inner exception.</typeparam>
        </member>
        <member name="M:FluentAssertions.Specialized.ExceptionAssertions`1.WithInnerException``1(System.String,System.Object[])">

              Asserts that the thrown exception contains an inner exception of type <typeparamref name = "TInnerException" />.

            <typeparam name = "TInnerException">The expected type of the inner exception.</typeparam>
            <param name = "reason">The reason why the inner exception should be of the supplied type.</param>
            <param name = "reasonArgs">The parameters used when formatting the <paramref name = "reason" />.</param>
        </member>
        <member name="M:FluentAssertions.Specialized.ExceptionAssertions`1.WithInnerMessage(System.String,FluentAssertions.ComparisonMode)">

              Asserts that the thrown exception contains an inner exception with the <paramref name = "expectedInnerMessage" />.

            <param name = "expectedInnerMessage">The expected message of the inner exception.</param>
            <param name = "comparisonMode">Determines how the expected message is compared with the actual message.</param>
        </member>
        <member name="M:FluentAssertions.Specialized.ExceptionAssertions`1.WithInnerMessage(System.String,System.String,System.Object[])">

              Asserts that the thrown exception contains an inner exception with the <paramref name = "expectedInnerMessage" />.

            <param name = "expectedInnerMessage">The expected message of the inner exception.</param>
            <param name = "reason">
              The reason why the message of the inner exception should match <paramref name = "expectedInnerMessage" />.
            </param>
            <param name = "reasonArgs">The parameters used when formatting the <paramref name = "reason" />.</param>
        </member>
        <member name="M:FluentAssertions.Specialized.ExceptionAssertions`1.WithInnerMessage(System.String,FluentAssertions.ComparisonMode,System.String,System.Object[])">

              Asserts that the thrown exception contains an inner exception with the <paramref name = "expectedInnerMessage" />.

            <param name = "expectedInnerMessage">The expected message of the inner exception.</param>
            <param name = "comparisonMode">Determines how the expected message is compared with the actual message.</param>
            <param name = "reason">
              The reason why the message of the inner exception should match <paramref name = "expectedInnerMessage" />.
            </param>
            <param name = "reasonArgs">The parameters used when formatting the <paramref name = "reason" />.</param>
        </member>
        <member name="M:FluentAssertions.Specialized.ExceptionAssertions`1.Where(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}},System.String,System.Object[])">

              Asserts that the exception matches a particular condition.

            <param name="exceptionExpression">
              The condition that the exception must match.
            </param>
            <param name="reason">
              A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
              start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
              Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="P:FluentAssertions.Specialized.ExceptionAssertions`1.And">

              Gets the exception object of the exception thrown.

        </member>
        <member name="T:FluentAssertions.Specialized.ExecutionTimeAssertions">

            Provides methods for asserting that the execution time of an <see cref="T:System.Action"/> satifies certain conditions.

        </member>
        <member name="M:FluentAssertions.Specialized.ExecutionTimeAssertions.#ctor(System.Action)">

            Initializes a new instance of the <see cref="T:FluentAssertions.Specialized.ExecutionTimeAssertions"/> class.

            <param name="action">The action of which the execution time must be asserted.</param>
        </member>
        <member name="M:FluentAssertions.Specialized.ExecutionTimeAssertions.ShouldNotExceed(System.TimeSpan,System.String,System.Object[])">

            Asserts that the execution time of the operation does not exceed a specified amount of time.

            <param name="maxDuration">
            The maximum allowed duration.
            </param>
            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="T:FluentAssertions.Specialized.MemberExecutionTimeAssertions`1">

            Provides methods for asserting that the execution time of an object member satifies certain conditions.

            <typeparam name="T"></typeparam>
        </member>
        <member name="M:FluentAssertions.Specialized.MemberExecutionTimeAssertions`1.#ctor(`0,System.Linq.Expressions.Expression{System.Action{`0}})">

            Initializes a new instance of the <see cref="T:FluentAssertions.Specialized.MemberExecutionTimeAssertions`1"/> class.

            <param name="subject">The object that exposes the method or property.</param>
            <param name="action">A reference to the method or property to measure the execution time of.</param>
        </member>
        <member name="T:FluentAssertions.Equivalency.AllDeclaredPublicPropertiesSelectionRule">

            Selection rule that adds all public properties of the subject as far as they are defined on the declared
            type.

        </member>
        <member name="T:FluentAssertions.Equivalency.ISelectionRule">

            Represents a rule that defines which properties of the subject-under-test to include while comparing
            two objects for structural equality.

        </member>
        <member name="M:FluentAssertions.Equivalency.ISelectionRule.SelectProperties(System.Collections.Generic.IEnumerable{System.Reflection.PropertyInfo},FluentAssertions.Equivalency.ISubjectInfo)">

            Adds or removes properties to/from the collection of subject properties that must be included while
            comparing two objects for structural equality.

            <param name="properties">
            A collection of properties that was prepopulated by other selection rules. Can be empty.</param>
            <param name="info">
            Type info about the subject.
            </param>
            <returns>
            The collection of properties after applying this rule. Can contain less or more than was passed in.
            </returns>
        </member>
        <member name="M:FluentAssertions.Equivalency.AllDeclaredPublicPropertiesSelectionRule.SelectProperties(System.Collections.Generic.IEnumerable{System.Reflection.PropertyInfo},FluentAssertions.Equivalency.ISubjectInfo)">

            Adds or removes properties to/from the collection of subject properties that must be included while
            comparing two objects for structural equality.

            <param name="properties">
            A collection of properties that was prepopulated by other selection rules. Can be empty.</param>
            <returns>
            The collection of properties after applying this rule. Can contain less or more than was passed in.
            </returns>
        </member>
        <member name="M:FluentAssertions.Equivalency.AllDeclaredPublicPropertiesSelectionRule.ToString">

            Returns a string that represents the current object.

            <returns>
            A string that represents the current object.
            </returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="T:FluentAssertions.Equivalency.AllRuntimePublicPropertiesSelectionRule">

            Selection rule that adds all public properties of the subject based on its run-time type rather than its
            declared type.

        </member>
        <member name="M:FluentAssertions.Equivalency.AllRuntimePublicPropertiesSelectionRule.SelectProperties(System.Collections.Generic.IEnumerable{System.Reflection.PropertyInfo},FluentAssertions.Equivalency.ISubjectInfo)">

            Adds or removes properties to/from the collection of subject properties that must be included while
            comparing two objects for structural equality.

            <param name="properties">
            A collection of properties that was prepopulated by other selection rules. Can be empty.</param>
            <returns>
            The collection of properties after applying this rule. Can contain less or more than was passed in.
            </returns>
        </member>
        <member name="M:FluentAssertions.Equivalency.AllRuntimePublicPropertiesSelectionRule.ToString">

            Returns a string that represents the current object.

            <returns>
            A string that represents the current object.
            </returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="M:FluentAssertions.Equivalency.IEquivalencyStep.CanHandle(FluentAssertions.Equivalency.EquivalencyValidationContext)">

            Gets a value indicating whether this step can handle the current subject and/or expectation.

        </member>
        <member name="M:FluentAssertions.Equivalency.IEquivalencyStep.Handle(FluentAssertions.Equivalency.EquivalencyValidationContext,FluentAssertions.Equivalency.IEquivalencyValidator)">

            Applies a step as part of the task to compare two objects for structural equality.

            <value>
            Should return <c>true</c> if the subject matches the expectation or if no additional assertions
            have to be executed. Should return <c>false</c> otherwise.
            </value>
            <remarks>
            May throw when preconditions are not met or if it detects mismatching data.
            </remarks>
        </member>
        <member name="M:FluentAssertions.Equivalency.ApplyAssertionRulesEquivalencyStep.CanHandle(FluentAssertions.Equivalency.EquivalencyValidationContext)">

            Gets a value indicating whether this step can handle the current subject and/or expectation.

        </member>
        <member name="M:FluentAssertions.Equivalency.ApplyAssertionRulesEquivalencyStep.Handle(FluentAssertions.Equivalency.EquivalencyValidationContext,FluentAssertions.Equivalency.IEquivalencyValidator)">

            Applies a step as part of the task to compare two objects for structural equality.

            <value>
            Should return <c>true</c> if the subject matches the expectation or if no additional assertions
            have to be executed. Should return <c>false</c> otherwise.
            </value>
            <remarks>
            May throw when preconditions are not met or if it detects mismatching data.
            </remarks>
        </member>
        <member name="T:FluentAssertions.Equivalency.AssertionRule`1">

            General purpose implementation of <see cref="T:FluentAssertions.Equivalency.IAssertionRule"/> that uses a predicate to determine whether
            this rule applies to a particular property and executes an action to assert equality.

            <typeparam name="TSubject">The type of the subject.</typeparam>
        </member>
        <member name="M:FluentAssertions.Equivalency.IAssertionRule.AssertEquality(FluentAssertions.Equivalency.IEquivalencyValidationContext)">

            Defines how a subject's property is compared for equality with the same property of the expectation.

            <param name="subjectProperty">
            Provides details about the subject's property.
            </param>
            <param name="subject">
            The value of the subject's property.
            </param>
            <param name="expectation">
            The value of a property on expectation object that was identified
            </param>
            <returns>
            Returns <c>true</c> if the rule was applied correctly and the assertion didn't cause any exceptions.
            Returns <c>false</c> if this rule doesn't support the subject's type.
            Throws if the rule did support the data type but assertion fails.
            </returns>
        </member>
        <member name="M:FluentAssertions.Equivalency.AssertionRule`1.AssertEquality(FluentAssertions.Equivalency.IEquivalencyValidationContext)">

            Defines how a subject's property is compared for equality with the same property of the expectation.

            <param name="subjectProperty">
            Provides details about the subject's property.
            </param>
            <param name="subject">
            The value of the subject's property.
            </param>
            <param name="expectation">
            The value of a property on expectation object that was identified
            </param>
            <returns>
            Returns <c>true</c> if the rule was applied correctly and the assertion didn't cause any exceptions.
            Returns <c>false</c> if this rule doesn't support the subject's type.
            Throws if the rule did support the data type but assertion fails.
            </returns>
        </member>
        <member name="T:FluentAssertions.Equivalency.IAssertionContext`1">

            Provides the required information for executing an equality assertion between a subject and an expectation.

            <typeparam name="TSubject">The type of the subject.</typeparam>
        </member>
        <member name="P:FluentAssertions.Equivalency.IAssertionContext`1.SubjectProperty">

            Gets the <see cref="T:System.Reflection.PropertyInfo"/> of the property that returned the current object, or <c>null</c> if the current
            object represents the root object.

        </member>
        <member name="P:FluentAssertions.Equivalency.IAssertionContext`1.Subject">

            Gets the value of the <see cref="P:FluentAssertions.Equivalency.IAssertionContext`1.SubjectProperty"/>

        </member>
        <member name="P:FluentAssertions.Equivalency.IAssertionContext`1.Expectation">

            Gets the value of the expectation object that was matched with the subject using a <see cref="T:FluentAssertions.Equivalency.IMatchingRule"/>.

        </member>
        <member name="P:FluentAssertions.Equivalency.IAssertionContext`1.Reason">

            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.

        </member>
        <member name="P:FluentAssertions.Equivalency.IAssertionContext`1.ReasonArgs">

            Zero or more objects to format using the placeholders in <see cref="P:FluentAssertions.Equivalency.IAssertionContext`1.Reason"/>.

        </member>
        <member name="T:FluentAssertions.Equivalency.ExcludePropertyByPredicateSelectionRule">

            Selection rule that removes a particular property from the structural comparison based on a predicate.

        </member>
        <member name="M:FluentAssertions.Equivalency.ExcludePropertyByPredicateSelectionRule.SelectProperties(System.Collections.Generic.IEnumerable{System.Reflection.PropertyInfo},FluentAssertions.Equivalency.ISubjectInfo)">

            Adds or removes properties to/from the collection of subject properties that must be included while
            comparing two objects for structural equality.

            <param name="properties">
            A collection of properties that was prepopulated by other selection rules. Can be empty.</param>
            <returns>
            The collection of properties after applying this rule. Can contain less or more than was passed in.
            </returns>
        </member>
        <member name="M:FluentAssertions.Equivalency.ExcludePropertyByPredicateSelectionRule.ToString">

            Returns a string that represents the current object.

            <returns>
            A string that represents the current object.
            </returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="T:FluentAssertions.Equivalency.ISubjectInfo">

            Provides details about the subject's root or nested property.

        </member>
        <member name="P:FluentAssertions.Equivalency.ISubjectInfo.PropertyInfo">

            Gets the <see cref="P:FluentAssertions.Equivalency.ISubjectInfo.PropertyInfo"/> of the property that returned the current object, or <c>null</c> if the current
            object represents the root object.

        </member>
        <member name="P:FluentAssertions.Equivalency.ISubjectInfo.PropertyPath">

            Gets the full path from the root object until the current object separated by dots.

        </member>
        <member name="P:FluentAssertions.Equivalency.ISubjectInfo.PropertyDescription">

            Gets a display-friendly representation of the <see cref="P:FluentAssertions.Equivalency.ISubjectInfo.PropertyPath"/>.

        </member>
        <member name="P:FluentAssertions.Equivalency.ISubjectInfo.CompileTimeType">

            Gets the compile-time type of the current object. If the current object is not the root object, then it returns the
            same <see cref="T:System.Type"/> as the <see cref="P:FluentAssertions.Equivalency.ISubjectInfo.RuntimeType"/> property does.

        </member>
        <member name="P:FluentAssertions.Equivalency.ISubjectInfo.RuntimeType">

            Gets the run-time type of the current object.

        </member>
        <member name="T:FluentAssertions.Equivalency.NestedSelectionContext">

            Represents a selection context of a nested property

        </member>
        <member name="P:FluentAssertions.Equivalency.NestedSelectionContext.PropertyInfo">

            Gets the <see cref="P:FluentAssertions.Equivalency.ISubjectInfo.PropertyInfo"/> of the property that returned the current object, or
            <c>null</c> if the current  object represents the root object.

        </member>
        <member name="P:FluentAssertions.Equivalency.NestedSelectionContext.PropertyPath">

            Gets the full path from the root object until the current property, separated by dots.

        </member>
        <member name="P:FluentAssertions.Equivalency.NestedSelectionContext.PropertyDescription">

            Gets a textual description of the current property based on the <see cref="P:FluentAssertions.Equivalency.ISubjectInfo.PropertyPath"/>.

        </member>
        <member name="P:FluentAssertions.Equivalency.NestedSelectionContext.CompileTimeType">

            Gets the compile-time type of the current object. If the current object is not the root object, then it returns the
            same <see cref="T:System.Type"/> as the <see cref="P:FluentAssertions.Equivalency.ISubjectInfo.RuntimeType"/> property does.

        </member>
        <member name="P:FluentAssertions.Equivalency.NestedSelectionContext.RuntimeType">

            Gets the run-time type of the current object.

        </member>
        <member name="T:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1">

            Is responsible for the exact run-time behavior of a structural equality comparison.

            <typeparam name="TSubject">The type of the subject.</typeparam>
        </member>
        <member name="T:FluentAssertions.Equivalency.IEquivalencyAssertionOptions">

            Provides the run-time details of the <see cref="T:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1"/> class.

        </member>
        <member name="P:FluentAssertions.Equivalency.IEquivalencyAssertionOptions.SelectionRules">

            Gets an ordered collection of selection rules that define what properties are included.

        </member>
        <member name="P:FluentAssertions.Equivalency.IEquivalencyAssertionOptions.MatchingRules">

            Gets an ordered collection of matching rules that determine which subject properties are matched with which
            expectation properties.

        </member>
        <member name="P:FluentAssertions.Equivalency.IEquivalencyAssertionOptions.AssertionRules">

            Gets an ordered collection of assertion rules that determine how subject properties are compared for equality with
            expectation properties.

        </member>
        <member name="P:FluentAssertions.Equivalency.IEquivalencyAssertionOptions.IsRecursive">

            Gets or sets a value indicating whether or not the assertion must perform a deep comparison.

        </member>
        <member name="F:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Default">

            Gets a configuration that compares all declared properties of the subject with equally named properties of the expectation,
            and includes the entire object graph. The names of the properties between the subject and expectation must match.

        </member>
        <member name="F:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Empty">

            Gets a configuration that by default doesn't include any of the subject's properties and doesn't consider any nested objects
            or collections.

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.IncludingAllDeclaredProperties">

            Adds all public properties of the subject as far as they are defined on the declared type.

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.IncludingAllRuntimeProperties">

            Adds all public properties of the subject based on its run-time type rather than its declared type.

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.ExcludingMissingProperties">

            Tries to match the properties of the subject with equally named properties on the expectation. Ignores those
            properties that don't exist on the expectation.

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.ThrowingOnMissingProperties">

            Requires the expectation to have properties which are equally named to properties on the subject.

            <returns></returns>
        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Excluding(System.Linq.Expressions.Expression{System.Func{`0,System.Object}})">

            Excludes the specified (nested) property from the structural equality check.

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Excluding(System.Linq.Expressions.Expression{System.Func{FluentAssertions.Equivalency.ISubjectInfo,System.Boolean}})">

            Excludes a (nested) property based on a predicate from the structural equality check.

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Including(System.Linq.Expressions.Expression{System.Func{`0,System.Object}})">

            Includes the specified property in the equality check.

            <remarks>
            This overrides the default behavior of including all declared properties.
            </remarks>
        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Using``1(System.Action{FluentAssertions.Equivalency.IAssertionContext{``0}})">
            <param name="action">
            The assertion to execute when the predicate is met.
            </param>
        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.IncludingNestedObjects">

            Causes the structural equality check to include nested collections and complex types.

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.IgnoringCyclicReferences">

            Causes the structural equality check to ignore any cyclic references.

            <remarks>
            By default, cyclic references within the object graph will cause an exception to be thrown.
            </remarks>
        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.WithoutSelectionRules">

            Clears all selection rules, including those that were added by default.

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.WithoutMatchingRules">

            Clears all matching rules, including those that were added by default.

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Using(FluentAssertions.Equivalency.ISelectionRule)">

            Adds a selection rule to the ones allready added by default and which is evaluated after all existing rules.

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Using(FluentAssertions.Equivalency.IMatchingRule)">

            Adds a matching rule to the ones allready added by default and which is evaluated before all existing rules.

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Using(FluentAssertions.Equivalency.IAssertionRule)">

            Adds a matching rule to the ones allready added by default and which is evaluated before all existing rules

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.ToString">

            Returns a string that represents the current object.

            <returns>
            A string that represents the current object.
            </returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.SelectionRules">

            Gets an ordered collection of selection rules that define what properties are included.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.MatchingRules">

            Gets an ordered collection of matching rules that determine which subject properties are matched with which
            expectation properties.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.AssertionRules">

            Gets an ordered collection of assertion rules that determine how subject properties are compared for equality with
            expectation properties.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.IsRecursive">

            Gets value indicating whether the equality check will include nested collections and complex types.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.CyclicReferenceHandling">

            Gets value indicating how cyclic references should be handled. By default, it will throw an exception.

        </member>
        <member name="T:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Restriction`1">

            Defines additional overrides when used with <see cref="!:EquivalencyAssertionOptions<TSubject>.When"/>

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Restriction`1.WhenTypeIs``1">

            Allows overriding the way structural equality is applied to (nested) objects of tyoe <typeparamref name="TPropertyType"/>

        </member>
        <member name="M:FluentAssertions.Equivalency.EquivalencyAssertionOptions`1.Restriction`1.When(System.Func{FluentAssertions.Equivalency.ISubjectInfo,System.Boolean})">

            Allows overriding the way structural equality is applied to particular properties.

            <param name="predicate">
            A predicate based on the <see cref="T:FluentAssertions.Equivalency.ISubjectInfo"/> of the subject that is used to identify the property for which the
            override applies.
            </param>
        </member>
        <member name="M:FluentAssertions.Equivalency.ComplexTypeEquivalencyStep.CanHandle(FluentAssertions.Equivalency.EquivalencyValidationContext)">

            Gets a value indicating whether this step can handle the current subject and/or expectation.

        </member>
        <member name="M:FluentAssertions.Equivalency.ComplexTypeEquivalencyStep.Handle(FluentAssertions.Equivalency.EquivalencyValidationContext,FluentAssertions.Equivalency.IEquivalencyValidator)">

            Applies a step as part of the task to compare two objects for structural equality.

            <value>
            Should return <c>true</c> if the subject matches the expectation or if no additional assertions
            have to be executed. Should return <c>false</c> otherwise.
            </value>
            <remarks>
            May throw when preconditions are not met or if it detects mismatching data.
            </remarks>
        </member>
        <member name="T:FluentAssertions.Equivalency.CyclicReferenceHandling">

            Indication of how cyclic references should be handled when validating equality of nested properties.

        </member>
        <member name="F:FluentAssertions.Equivalency.CyclicReferenceHandling.Ignore">

            Cyclic references will be ignored.

        </member>
        <member name="F:FluentAssertions.Equivalency.CyclicReferenceHandling.ThrowException">

            Cyclic references will result in an exception.

        </member>
        <member name="M:FluentAssertions.Equivalency.EnumerableEquivalencyStep.CanHandle(FluentAssertions.Equivalency.EquivalencyValidationContext)">

            Gets a value indicating whether this step can handle the current subject and/or expectation.

        </member>
        <member name="M:FluentAssertions.Equivalency.EnumerableEquivalencyStep.Handle(FluentAssertions.Equivalency.EquivalencyValidationContext,FluentAssertions.Equivalency.IEquivalencyValidator)">

            Applies a step as part of the task to compare two objects for structural equality.

            <value>
            Should return <c>true</c> if the subject matches the expectation or if no additional assertions
            have to be executed. Should return <c>false</c> otherwise.
            </value>
            <remarks>
            May throw when preconditions are not met or if it detects mismatching data.
            </remarks>
        </member>
        <member name="M:FluentAssertions.Equivalency.SimpleEqualityEquivalencyStep.CanHandle(FluentAssertions.Equivalency.EquivalencyValidationContext)">

            Gets a value indicating whether this step can handle the current subject and/or expectation.

        </member>
        <member name="M:FluentAssertions.Equivalency.SimpleEqualityEquivalencyStep.Handle(FluentAssertions.Equivalency.EquivalencyValidationContext,FluentAssertions.Equivalency.IEquivalencyValidator)">

            Applies a step as part of the task to compare two objects for structural equality.

            <value>
            Should return <c>true</c> if the subject matches the expectation or if no additional assertions
            have to be executed. Should return <c>false</c> otherwise.
            </value>
            <remarks>
            May throw when preconditions are not met or if it detects mismatching data.
            </remarks>
        </member>
        <member name="T:FluentAssertions.Equivalency.ExcludePropertyByPathSelectionRule">

            Selection rule that removes a particular property from the structural comparison.

        </member>
        <member name="M:FluentAssertions.Equivalency.ExcludePropertyByPathSelectionRule.SelectProperties(System.Collections.Generic.IEnumerable{System.Reflection.PropertyInfo},FluentAssertions.Equivalency.ISubjectInfo)">

            Adds or removes properties to/from the collection of subject properties that must be included while
            comparing two objects for structural equality.

            <param name="properties">
            A collection of properties that was prepopulated by other selection rules. Can be empty.
            </param>
            <returns>
            The collection of properties after applying this rule. Can contain less or more than was passed in.
            </returns>
        </member>
        <member name="M:FluentAssertions.Equivalency.ExcludePropertyByPathSelectionRule.ToString">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="T:FluentAssertions.Equivalency.IMatchingRule">

            Represents a rule that defines how to map the properties from the subject-under-test with the properties
            on the expectation object.

        </member>
        <member name="M:FluentAssertions.Equivalency.IMatchingRule.Match(System.Reflection.PropertyInfo,System.Object,System.String)">

            Attempts to find a property on the expectation that should be compared with the
            <paramref name="subjectProperty"/> during a structural equality.

            <remarks>
            Whether or not a match is required or optional is up to the specific rule. If no match is found and this is not an issue,
            simply return <c>null</c>.
            </remarks>
            <param name="subjectProperty">
            The <see cref="T:System.Reflection.PropertyInfo"/> of the subject's property for which a match must be found. Can never
            be <c>null</c>.
            </param>
            <param name="expectation">
            The expectation object for which a matching property must be returned. Can never be <c>null</c>.
            </param>
            <param name="propertyPath">
            The dotted path from the root object to the current property. Will never  be <c>null</c>.
            </param>
            <returns>
            Returns the <see cref="T:System.Reflection.PropertyInfo"/> of the property with which to compare the subject with, or <c>null</c>
            if no match was found.
            </returns>
        </member>
        <member name="T:FluentAssertions.Equivalency.IncludePropertySelectionRule">

            Selection rule that includes a particular property in the structural comparison.

        </member>
        <member name="M:FluentAssertions.Equivalency.IncludePropertySelectionRule.SelectProperties(System.Collections.Generic.IEnumerable{System.Reflection.PropertyInfo},FluentAssertions.Equivalency.ISubjectInfo)">

            Adds or removes properties to/from the collection of subject properties that must be included while
            comparing two objects for structural equality.

            <param name="properties">
            A collection of properties that was prepopulated by other selection rules. Can be empty.</param>
            <returns>
            The collection of properties after applying this rule. Can contain less or more than was passed in.
            </returns>
        </member>
        <member name="M:FluentAssertions.Equivalency.IncludePropertySelectionRule.ToString">

            Returns a <see cref="T:System.String"/> that represents this instance.

            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="T:FluentAssertions.Equivalency.IEquivalencyValidationContext">

            Provides information on a particular property during an assertion for structural equality of two object graphs.

        </member>
        <member name="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.MatchingExpectationProperty">

            Gets the property of the <see cref="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.Expectation"/> that was matched against the <see cref="!:SubjectProperty"/>,
            or <c>null</c> if <see cref="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.IsRoot"/> is <c>true</c>.

        </member>
        <member name="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.Expectation">

            Gets the value of the <see cref="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.MatchingExpectationProperty"/>.

        </member>
        <member name="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.Reason">

            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.

        </member>
        <member name="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.ReasonArgs">

            Zero or more objects to format using the placeholders in <see cref="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.Reason"/>.

        </member>
        <member name="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.Verification">

            Gets a verification object associated with the current <see cref="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.Reason"/> and <see cref="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.ReasonArgs"/>.

        </member>
        <member name="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.IsRoot">

            Gets a value indicating whether the current context represents the root of the object graph.

        </member>
        <member name="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.Subject">

            Gets the value of the <see cref="!:ISelectionContext.PropertyInfo"/>

        </member>
        <member name="T:FluentAssertions.Equivalency.MustMatchByNameRule">

            Requires the expectation object to have a property with the exact same name.

        </member>
        <member name="M:FluentAssertions.Equivalency.MustMatchByNameRule.Match(System.Reflection.PropertyInfo,System.Object,System.String)">

            Attempts to find a property on the expectation that should be compared with the
            <paramref name="subjectProperty"/> during a structural equality.

            <remarks>
            Whether or not a match is required or optional is up to the specific rule. If no match is found and this is not an issue,
            simply return <c>null</c>.
            </remarks>
            <param name="subjectProperty">
            The <see cref="T:System.Reflection.PropertyInfo"/> of the subject's property for which a match must be found. Can never
            be <c>null</c>.
            </param>
            <param name="expectation">
            The expectation object for which a matching property must be returned. Can never be <c>null</c>.
            </param>
            <param name="propertyPath">
            The dotted path from the root object to the current property. Will never  be <c>null</c>.
            </param>
            <returns>
            Returns the <see cref="T:System.Reflection.PropertyInfo"/> of the property with which to compare the subject with, or <c>null</c>
            if no match was found.
            </returns>
        </member>
        <member name="M:FluentAssertions.Equivalency.MustMatchByNameRule.ToString">

            Returns a string that represents the current object.

            <returns>
            A string that represents the current object.
            </returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="T:FluentAssertions.Equivalency.PropertyAssertions`1">

            Provides methods for selecting one or more properties of an object and comparing them with another object.

        </member>
        <member name="M:FluentAssertions.Equivalency.PropertyAssertions`1.AllProperties">

            Includes all properties of <typeparamref name="T"/> when comparing the subject with another object using <see cref="!:EqualTo(object)"/>.

        </member>
        <member name="M:FluentAssertions.Equivalency.PropertyAssertions`1.AllRuntimeProperties">

            Includes all properties of <typeparamref name="T"/> including those of the run-time type when comparing the subject
            with another object using <see cref="!:EqualTo(object)"/>.

        </member>
        <member name="M:FluentAssertions.Equivalency.PropertyAssertions`1.SharedProperties">

            Includes all properties of <typeparamref name="T"/> when comparing the subject with another object using <see cref="!:EqualTo(object)"/>,
            except those that the other object does not have.

        </member>
        <member name="M:FluentAssertions.Equivalency.PropertyAssertions`1.IncludingNestedObjects(FluentAssertions.Equivalency.CyclicReferenceHandling)">

            Perform recursive property comparison of the child properties for objects that are of incompatible type.

            <param name="cyclicReferenceHandling">
            Indication of how cyclic references in the nested properties should be handled. By default this will result in an
            exception, but if <see cref="F:FluentAssertions.Equivalency.CyclicReferenceHandling.Ignore"/> is specified, cyclic references will just be ignored.
            </param>
        </member>
        <member name="M:FluentAssertions.Equivalency.PropertyAssertions`1.AllPropertiesBut(System.Linq.Expressions.Expression{System.Func{`0,System.Object}},System.Linq.Expressions.Expression{System.Func{`0,System.Object}}[])">

            Includes all properties of <typeparamref name="T"/> when comparing the subject with another object using <see cref="!:EqualTo(object)"/>,
            except those specified using a property expression.

            <param name="propertyExpression">A single property expression to exclude.</param>
            <param name="propertyExpressions">Optional list of additional property expressions to exclude.</param>
        </member>
        <member name="M:FluentAssertions.Equivalency.PropertyAssertions`1.But(System.Linq.Expressions.Expression{System.Func{`0,System.Object}},System.Linq.Expressions.Expression{System.Func{`0,System.Object}}[])">

            Excludes the properties specified by the <paramref name="propertyExpression"/> from the comparison.

            <param name="propertyExpression">A single property expression to exclude.</param>
            <param name="propertyExpressions">Optional list of additional property expressions to exclude.</param>
        </member>
        <member name="M:FluentAssertions.Equivalency.PropertyAssertions`1.Properties(System.Linq.Expressions.Expression{System.Func{`0,System.Object}},System.Linq.Expressions.Expression{System.Func{`0,System.Object}}[])">

            Includes only those properties of <typeparamref name="T"/> when comparing the subject with another object using <see cref="!:EqualTo(object)"/>
            that were specified using a property expression.

            <param name="propertyExpression">A single property expression to include.</param>
            <param name="propertyExpressions">Optional list of additional property expressions to include.</param>
        </member>
        <member name="M:FluentAssertions.Equivalency.PropertyAssertions`1.EqualTo(System.Object,System.String,System.Object[])">

            Asserts that the previously selected properties of <typeparamref name="T"/> have the same value as the equally named
            properties of <paramref name="expectation"/>.

            <param name="expectation">The object to compare the current object with</param>
            <remarks>
            Property values are considered equal if, after converting them to the requested type, calling <see cref="!:EqualTo(object)"/>
            returns <c>true</c>.
            </remarks>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Equivalency.ReferenceEqualityEquivalencyStep.CanHandle(FluentAssertions.Equivalency.EquivalencyValidationContext)">

            Gets a value indicating whether this step can handle the current subject and/or expectation.

        </member>
        <member name="M:FluentAssertions.Equivalency.ReferenceEqualityEquivalencyStep.Handle(FluentAssertions.Equivalency.EquivalencyValidationContext,FluentAssertions.Equivalency.IEquivalencyValidator)">

            Applies a step as part of the task to compare two objects for structural equality.

            <value>
            Should return <c>true</c> if the subject matches the expectation or if no additional assertions
            have to be executed. Should return <c>false</c> otherwise.
            </value>
            <remarks>
            May throw when preconditions are not met or if it detects mismatching data.
            </remarks>
        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyValidationContext.PropertyInfo">

            Gets the <see cref="P:FluentAssertions.Equivalency.ISubjectInfo.PropertyInfo"/> of the property that returned the current object, or
            <c>null</c> if the current object represents the root object.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyValidationContext.PropertyPath">

              Gets the full path from the root object until the current property, separated by dots.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyValidationContext.PropertyDescription">

              Gets a textual description of the current property based on the <see cref="P:FluentAssertions.Equivalency.EquivalencyValidationContext.PropertyPath"/>.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyValidationContext.Subject">

            Gets the value of the <see cref="P:FluentAssertions.Equivalency.ISubjectInfo.PropertyInfo"/>

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyValidationContext.MatchingExpectationProperty">

            Gets the property of the <see cref="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.Expectation"/> that was matched against the <see cref="P:FluentAssertions.Equivalency.ISubjectInfo.PropertyInfo"/>,
            or <c>null</c> if <see cref="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.IsRoot"/> is <c>true</c>.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyValidationContext.Expectation">

            Gets the value of the <see cref="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.MatchingExpectationProperty"/>.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyValidationContext.Reason">

              A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
              is needed. If the phrase does not start with the word because, it is prepended automatically.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyValidationContext.ReasonArgs">

              Zero or more objects to format using the placeholders in <see cref="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.Reason"/>.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyValidationContext.IsRoot">

              Gets a value indicating whether the current context represents the root of the object graph.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyValidationContext.CompileTimeType">

            Gets the compile-time type of the current object. If the current object is not the root object, then it returns the
            same <see cref="T:System.Type"/> as the <see cref="P:FluentAssertions.Equivalency.ISubjectInfo.RuntimeType"/> property does.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyValidationContext.RuntimeType">

            Gets the run-time type of the current object.

        </member>
        <member name="P:FluentAssertions.Equivalency.EquivalencyValidationContext.Verification">

              Gets a verification object associated with the current <see cref="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.Reason"/> and <see cref="P:FluentAssertions.Equivalency.IEquivalencyValidationContext.ReasonArgs"/>.

        </member>
        <member name="T:FluentAssertions.Equivalency.EquivalencyValidator">

            Is responsible for validating the equality of one or more properties of a subject with another object.

        </member>
        <member name="M:FluentAssertions.Equivalency.TryConversionEquivalencyStep.CanHandle(FluentAssertions.Equivalency.EquivalencyValidationContext)">

            Gets a value indicating whether this step can handle the current subject and/or expectation.

        </member>
        <member name="M:FluentAssertions.Equivalency.TryConversionEquivalencyStep.Handle(FluentAssertions.Equivalency.EquivalencyValidationContext,FluentAssertions.Equivalency.IEquivalencyValidator)">

            Applies a step as part of the task to compare two objects for structural equality.

            <value>
            Should return <c>true</c> if the subject matches the expectation or if no additional assertions
            have to be executed. Should return <c>false</c> otherwise.
            </value>
            <remarks>
            May throw when preconditions are not met or if it detects mismatching data.
            </remarks>
        </member>
        <member name="T:FluentAssertions.Equivalency.TryMatchByNameRule">

            Finds a property of the expectation with the exact same name, but doesn't require it.

        </member>
        <member name="M:FluentAssertions.Equivalency.TryMatchByNameRule.Match(System.Reflection.PropertyInfo,System.Object,System.String)">

            Attempts to find a property on the expectation that should be compared with the
            <paramref name="subjectProperty"/> during a structural equality.

            <remarks>
            Whether or not a match is required or optional is up to the specific rule. If no match is found and this is not an issue,
            simply return <c>null</c>.
            </remarks>
            <param name="subjectProperty">
            The <see cref="T:System.Reflection.PropertyInfo"/> of the subject's property for which a match must be found. Can never
            be <c>null</c>.
            </param>
            <param name="expectation">
            The expectation object for which a matching property must be returned. Can never be <c>null</c>.
            </param>
            <param name="propertyPath">
            The dotted path from the root object to the current property. Will never  be <c>null</c>.
            </param>
            <returns>
            Returns the <see cref="T:System.Reflection.PropertyInfo"/> of the property with which to compare the subject with, or <c>null</c>
            if no match was found.
            </returns>
        </member>
        <member name="M:FluentAssertions.Equivalency.TryMatchByNameRule.ToString">

            Returns a string that represents the current object.

            <returns>
            A string that represents the current object.
            </returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="T:FluentAssertions.TimeSpanConversionExtensions">

            Extension methods on <see cref="T:System.Int32"/> to allow for a more fluent way of specifying a <see cref="T:System.TimeSpan"/>.

            <example>
            Instead of

            TimeSpan.FromHours(12)

            you can write

            12.Hours()

            Or even

            12.Hours().And(30.Minutes()).
            </example>
            <seealso cref="T:FluentAssertions.FluentDateTimeExtensions"/>
        </member>
        <member name="M:FluentAssertions.TimeSpanConversionExtensions.Milliseconds(System.Int32)">

            Returns a <see cref="T:System.TimeSpan"/> based on a number of milliseconds.

        </member>
        <member name="M:FluentAssertions.TimeSpanConversionExtensions.Seconds(System.Int32)">

            Returns a <see cref="T:System.TimeSpan"/> based on a number of seconds.

        </member>
        <member name="M:FluentAssertions.TimeSpanConversionExtensions.Seconds(System.Int32,System.TimeSpan)">

            Returns a <see cref="T:System.TimeSpan"/> based on a number of seconds, and add the specified
            <paramref name="offset"/>.

        </member>
        <member name="M:FluentAssertions.TimeSpanConversionExtensions.Minutes(System.Int32)">

            Returns a <see cref="T:System.TimeSpan"/> based on a number of minutes.

        </member>
        <member name="M:FluentAssertions.TimeSpanConversionExtensions.Minutes(System.Int32,System.TimeSpan)">

            Returns a <see cref="T:System.TimeSpan"/> based on a number of minutes, and add the specified
            <paramref name="offset"/>.

        </member>
        <member name="M:FluentAssertions.TimeSpanConversionExtensions.Hours(System.Int32)">

            Returns a <see cref="T:System.TimeSpan"/> based on a number of hours.

        </member>
        <member name="M:FluentAssertions.TimeSpanConversionExtensions.Hours(System.Int32,System.TimeSpan)">

            Returns a <see cref="T:System.TimeSpan"/> based on a number of hours, and add the specified
            <paramref name="offset"/>.

        </member>
        <member name="M:FluentAssertions.TimeSpanConversionExtensions.Days(System.Int32)">

            Returns a <see cref="T:System.TimeSpan"/> based on a number of days.

        </member>
        <member name="M:FluentAssertions.TimeSpanConversionExtensions.Days(System.Int32,System.TimeSpan)">

            Returns a <see cref="T:System.TimeSpan"/> based on a number of days, and add the specified
            <paramref name="offset"/>.

        </member>
        <member name="M:FluentAssertions.TimeSpanConversionExtensions.And(System.TimeSpan,System.TimeSpan)">

            Convenience method for chaining multiple calls to the methods provided by this class.

            <example>
            23.Hours().And(59.Minutes())
            </example>
        </member>
        <member name="T:FluentAssertions.TypeExtensions">

            Extension methods for getting method and property selectors for a type.

        </member>
        <member name="M:FluentAssertions.TypeExtensions.Types(System.Reflection.Assembly)">

            Returns the types that are visible outside the specified <see cref="T:System.Reflection.Assembly"/>.

        </member>
        <member name="M:FluentAssertions.TypeExtensions.Methods(System.Type)">

            Returns a method selector for the current <see cref="T:System.Type"/>.

        </member>
        <member name="M:FluentAssertions.TypeExtensions.Methods(FluentAssertions.Types.TypeSelector)">

            Returns a method selector for the current <see cref="T:System.Type"/>.

        </member>
        <member name="M:FluentAssertions.TypeExtensions.Properties(System.Type)">

            Returns a property selector for the current <see cref="T:System.Type"/>.

        </member>
        <member name="M:FluentAssertions.TypeExtensions.Properties(FluentAssertions.Types.TypeSelector)">

            Returns a property selector for the current <see cref="T:System.Type"/>.

        </member>
        <member name="T:FluentAssertions.Types.AllTypes">

            Static class that allows for a 'fluent' selection of the types from an <see cref="T:System.Reflection.Assembly"/>.

            <example>
            AllTypes.From(myAssembly)

              .ThatImplement<ISomeInterface>

              .Should()

              .BeDecoratedWith<SomeAttribute>()
            </example>
        </member>
        <member name="M:FluentAssertions.Types.AllTypes.From(System.Reflection.Assembly)">

            Returns a <see cref="T:FluentAssertions.Types.TypeSelector"/> for selecting the types that are visible outside the
            specified <paramref name="assembly"/>.

            <param name="assembly">The assembly from which to select the types.</param>
        </member>
        <member name="T:FluentAssertions.Types.MethodInfoAssertions">

            Contains assertions for the <see cref="T:System.Reflection.MethodInfo"/> objects returned by the parent <see cref="T:FluentAssertions.Types.MethodInfoSelector"/>.

        </member>
        <member name="M:FluentAssertions.Types.MethodInfoAssertions.#ctor(System.Reflection.MethodInfo)">

            Initializes a new instance of the <see cref="T:FluentAssertions.Types.MethodInfoAssertions"/> class.

            <param name="methodInfo">The method to assert.</param>
        </member>
        <member name="M:FluentAssertions.Types.MethodInfoAssertions.#ctor(System.Collections.Generic.IEnumerable{System.Reflection.MethodInfo})">

            Initializes a new instance of the <see cref="T:FluentAssertions.Types.MethodInfoAssertions"/> class.

            <param name="methodInfo">The methods to assert.</param>
        </member>
        <member name="M:FluentAssertions.Types.MethodInfoAssertions.BeVirtual(System.String,System.Object[])">

            Asserts that the selected methods are virtual.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Types.MethodInfoAssertions.BeDecoratedWith``1(System.String,System.Object[])">

            Asserts that the selected methods are decorated with the specified <typeparamref name="TAttribute"/>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Types.MethodInfoAssertions.SubjectMethods">

            Gets the object which value is being asserted.

        </member>
        <member name="T:FluentAssertions.Types.MethodInfoSelector">

            Allows for fluent selection of methods of a type through reflection.

        </member>
        <member name="M:FluentAssertions.Types.MethodInfoSelector.#ctor(System.Type)">

            Initializes a new instance of the <see cref="T:FluentAssertions.Types.MethodInfoSelector"/> class.

            <param name="type">The type from which to select methods.</param>
        </member>
        <member name="M:FluentAssertions.Types.MethodInfoSelector.#ctor(System.Collections.Generic.IEnumerable{System.Type})">

            Initializes a new instance of the <see cref="T:FluentAssertions.Types.MethodInfoSelector"/> class.

            <param name="types">The types from which to select methods.</param>
        </member>
        <member name="M:FluentAssertions.Types.MethodInfoSelector.ThatReturn``1">

            Only select the methods that return the specified type

        </member>
        <member name="M:FluentAssertions.Types.MethodInfoSelector.ThatAreDecoratedWith``1">

            Only select the methods that are decorated with an attribute of the specified type.

        </member>
        <member name="M:FluentAssertions.Types.MethodInfoSelector.ToArray">

            The resulting <see cref="T:System.Reflection.MethodInfo"/> objects.

        </member>
        <member name="M:FluentAssertions.Types.MethodInfoSelector.HasSpecialName(System.Reflection.MethodInfo)">

            Determines whether the specified method has a special name (like properties and events).

        </member>
        <member name="M:FluentAssertions.Types.MethodInfoSelector.GetEnumerator">

            Returns an enumerator that iterates through the collection.

            <returns>
            A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
            </returns>
            <filterpriority>1</filterpriority>
        </member>
        <member name="M:FluentAssertions.Types.MethodInfoSelector.System#Collections#IEnumerable#GetEnumerator">

            Returns an enumerator that iterates through a collection.

            <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="P:FluentAssertions.Types.MethodInfoSelector.ThatArePublicOrInternal">

            Only select the methods that are public or internal.

        </member>
        <member name="P:FluentAssertions.Types.MethodInfoSelector.ThatReturnVoid">

            Only select the methods without a return value

        </member>
        <member name="T:FluentAssertions.Types.PropertyInfoAssertions">

            Contains assertions for the <see cref="T:System.Reflection.PropertyInfo"/> objects returned by the parent <see cref="T:FluentAssertions.Types.PropertyInfoSelector"/>.

        </member>
        <member name="M:FluentAssertions.Types.PropertyInfoAssertions.#ctor(System.Reflection.PropertyInfo)">

            Initializes a new instance of the <see cref="T:FluentAssertions.Types.PropertyInfoAssertions"/> class, for a single <see cref="T:System.Reflection.PropertyInfo"/>.

            <param name="property">The property to assert.</param>
        </member>
        <member name="M:FluentAssertions.Types.PropertyInfoAssertions.#ctor(System.Collections.Generic.IEnumerable{System.Reflection.PropertyInfo})">

            Initializes a new instance of the <see cref="T:FluentAssertions.Types.PropertyInfoAssertions"/> class, for a number of <see cref="T:System.Reflection.PropertyInfo"/> objects.

            <param name="properties">The properties to assert.</param>
        </member>
        <member name="M:FluentAssertions.Types.PropertyInfoAssertions.BeVirtual(System.String,System.Object[])">

            Asserts that the selected properties are virtual.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Types.PropertyInfoAssertions.BeDecoratedWith``1(System.String,System.Object[])">

            Asserts that the selected methods are decorated with the specified <typeparamref name="TAttribute"/>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Types.PropertyInfoAssertions.SubjectProperties">

            Gets the object which value is being asserted.

        </member>
        <member name="T:FluentAssertions.Types.PropertyInfoSelector">

            Allows for fluent selection of properties of a type through reflection.

        </member>
        <member name="M:FluentAssertions.Types.PropertyInfoSelector.#ctor(System.Type)">

            Initializes a new instance of the <see cref="T:FluentAssertions.Types.PropertyInfoSelector"/> class.

            <param name="type">The type from which to select properties.</param>
        </member>
        <member name="M:FluentAssertions.Types.PropertyInfoSelector.#ctor(System.Collections.Generic.IEnumerable{System.Type})">

            Initializes a new instance of the <see cref="T:FluentAssertions.Types.PropertyInfoSelector"/> class.

            <param name="types">The types from which to select properties.</param>
        </member>
        <member name="M:FluentAssertions.Types.PropertyInfoSelector.ThatAreDecoratedWith``1">

            Only select the properties that are decorated with an attribute of the specified type.

        </member>
        <member name="M:FluentAssertions.Types.PropertyInfoSelector.OfType``1">

            Only select the properties that return the specified type

        </member>
        <member name="M:FluentAssertions.Types.PropertyInfoSelector.ToArray">

            The resulting <see cref="T:System.Reflection.PropertyInfo"/> objects.

        </member>
        <member name="M:FluentAssertions.Types.PropertyInfoSelector.GetEnumerator">

            Returns an enumerator that iterates through the collection.

            <returns>
            A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
            </returns>
            <filterpriority>1</filterpriority>
        </member>
        <member name="M:FluentAssertions.Types.PropertyInfoSelector.System#Collections#IEnumerable#GetEnumerator">

            Returns an enumerator that iterates through a collection.

            <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="P:FluentAssertions.Types.PropertyInfoSelector.ThatArePublicOrInternal">

            Only select the properties that have a public or internal getter.

        </member>
        <member name="T:FluentAssertions.Types.TypeAssertions">

            Contains a number of methods to assert that a <see cref="T:System.Type"/> meets certain expectations.

        </member>
        <member name="M:FluentAssertions.Types.TypeAssertions.#ctor(System.Type)">

            Initializes a new instance of the <see cref="T:System.Object" /> class.

        </member>
        <member name="M:FluentAssertions.Types.TypeAssertions.Be``1(System.String,System.Object[])">

            Asserts that the current type is equal to the specified <typeparamref name="TExpected"/> type.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Types.TypeAssertions.Be(System.Type,System.String,System.Object[])">

            Asserts that the current type is equal to the specified <paramref name="expected"/> type.

            <param name="expected">The expected type</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Types.TypeAssertions.GetFailureMessageIfTypesAreDifferent(System.Type,System.Type)">

            Creates an error message in case the specifed <paramref name="actual"/> type differs from the
            <paramref name="expected"/> type.

            <returns>
            An empty <see cref="T:System.String"/> if the two specified types are the same, or an error message that describes that
            the two specified types are not the same.
            </returns>
        </member>
        <member name="M:FluentAssertions.Types.TypeAssertions.NotBe``1(System.String,System.Object[])">

            Asserts that the current type is not equal to the specified <typeparamref name="TUnexpected"/> type.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Types.TypeAssertions.NotBe(System.Type,System.String,System.Object[])">

            Asserts that the current type is not equal to the specified <paramref name="unexpected"/> type.

            <param name="unexpected">The unexpected type</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Types.TypeAssertions.BeDecoratedWith``1(System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Type"/> is decorated with the specified <typeparamref name="TAttribute"/>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Types.TypeAssertions.BeDecoratedWith``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Type"/> is decorated with an attribute of type <typeparamref name="TAttribute"/>
            that matches the specified <paramref name="isMatchingAttributePredicate"/>.

            <param name="isMatchingAttributePredicate">
            The predicate that the attribute must match.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Types.TypeAssertions.Subject">

            Gets the object which value is being asserted.

        </member>
        <member name="T:FluentAssertions.Types.TypeSelector">

            Allows for fluent filtering a list of types.

        </member>
        <member name="M:FluentAssertions.Types.TypeSelector.ToArray">

            The resulting <see cref="T:System.Type"/> objects.

        </member>
        <member name="M:FluentAssertions.Types.TypeSelector.ThatDeriveFrom``1">

            Determines whether a type is a subclass of another type, but NOT the same type.

        </member>
        <member name="M:FluentAssertions.Types.TypeSelector.ThatImplement``1">

            Determines whether a type implements an interface (but is not the interface itself).

        </member>
        <member name="M:FluentAssertions.Types.TypeSelector.ThatAreDecoratedWith``1">

            Determines whether a type is decorated with a particular attribute.

        </member>
        <member name="M:FluentAssertions.Types.TypeSelector.ThatAreInNamespace(System.String)">

            Determines whether the namespace of type is exactly <paramref name="namespace"/>.

        </member>
        <member name="M:FluentAssertions.Types.TypeSelector.ThatAreUnderNamespace(System.String)">

            Determines whether the namespace of type is starts with <paramref name="namespace"/>.

        </member>
        <member name="M:FluentAssertions.Types.TypeSelector.GetEnumerator">

            Returns an enumerator that iterates through the collection.

            <returns>
            A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
            </returns>
            <filterpriority>1</filterpriority>
        </member>
        <member name="M:FluentAssertions.Types.TypeSelector.System#Collections#IEnumerable#GetEnumerator">

            Returns an enumerator that iterates through a collection.

            <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="T:FluentAssertions.Types.TypeSelectorAssertions">

            Contains a number of methods to assert that all <see cref="T:System.Type"/>s in a <see cref="T:FluentAssertions.Types.TypeSelector"/>
            meet certain expectations.

        </member>
        <member name="M:FluentAssertions.Types.TypeSelectorAssertions.#ctor(System.Collections.Generic.IEnumerable{System.Type})">

            Initializes a new instance of the <see cref="T:System.Object" /> class.

        </member>
        <member name="M:FluentAssertions.Types.TypeSelectorAssertions.BeDecoratedWith``1(System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Type"/> is decorated with the specified <typeparamref name="TAttribute"/>.

            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Types.TypeSelectorAssertions.BeDecoratedWith``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Type"/> is decorated with an attribute of type <typeparamref name="TAttribute"/>
            that matches the specified <paramref name="isMatchingAttributePredicate"/>.

            <param name="isMatchingAttributePredicate">
            The predicate that the attribute must match.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Types.TypeSelectorAssertions.Subject">

            Gets the object which value is being asserted.

        </member>
        <member name="T:FluentAssertions.Xml.XAttributeAssertions">

            Contains a number of methods to assert that an <see cref="T:System.Xml.Linq.XAttribute"/> is in the expected state.

        </member>
        <member name="M:FluentAssertions.Xml.XAttributeAssertions.#ctor(System.Xml.Linq.XAttribute)">

            Initializes a new instance of the <see cref="T:FluentAssertions.Xml.XAttributeAssertions"/> class.

        </member>
        <member name="M:FluentAssertions.Xml.XAttributeAssertions.Be(System.Xml.Linq.XAttribute)">

            Asserts that the current <see cref="T:System.Xml.Linq.XAttribute"/> equals the <paramref name="expected"/> attribute.

            <param name="expected">The expected attribute</param>
        </member>
        <member name="M:FluentAssertions.Xml.XAttributeAssertions.Be(System.Xml.Linq.XAttribute,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Xml.Linq.XAttribute"/> equals the <paramref name="expected"/> attribute.

            <param name="expected">The expected attribute</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XAttributeAssertions.NotBe(System.Xml.Linq.XAttribute)">

            Asserts that the current <see cref="T:System.Xml.Linq.XAttribute"/> does not equal the <paramref name="unexpected"/> attribute,
            using its <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="unexpected">The unexpected attribute</param>
        </member>
        <member name="M:FluentAssertions.Xml.XAttributeAssertions.NotBe(System.Xml.Linq.XAttribute,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Xml.Linq.XAttribute"/> does not equal the <paramref name="unexpected"/> attribute,
            using its <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="unexpected">The unexpected attribute</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XAttributeAssertions.BeNull">

            Asserts that the <see cref="T:System.Xml.Linq.XAttribute"/> is <c>null</c>.

        </member>
        <member name="M:FluentAssertions.Xml.XAttributeAssertions.BeNull(System.String,System.Object[])">

            Asserts that the <see cref="T:System.Xml.Linq.XAttribute"/> is <c>null</c>.

            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XAttributeAssertions.NotBeNull">

            Asserts that the <see cref="T:System.Xml.Linq.XAttribute"/> is not <c>null</c>.

        </member>
        <member name="M:FluentAssertions.Xml.XAttributeAssertions.NotBeNull(System.String,System.Object[])">

            Asserts that the <see cref="T:System.Xml.Linq.XAttribute"/> is not <c>null</c>.

            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XAttributeAssertions.HaveValue(System.String)">

            Asserts that the current <see cref="T:System.Xml.Linq.XAttribute"/> has the specified <paramref name="expected"/> value.

            <param name="expected">The expected value</param>
        </member>
        <member name="M:FluentAssertions.Xml.XAttributeAssertions.HaveValue(System.String,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Xml.Linq.XAttribute"/> has the specified <paramref name="expected"/> value.

            <param name="expected">The expected value</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Xml.XAttributeAssertions.Subject">

            Gets the object which value is being asserted.

        </member>
        <member name="T:FluentAssertions.Xml.XDocumentAssertions">

            Contains a number of methods to assert that an <see cref="T:System.Xml.Linq.XDocument"/> is in the expected state.

        </member>
        <member name="M:FluentAssertions.Xml.XDocumentAssertions.#ctor(System.Xml.Linq.XDocument)">

            Initializes a new instance of the <see cref="T:FluentAssertions.Xml.XDocumentAssertions"/> class.

        </member>
        <member name="M:FluentAssertions.Xml.XDocumentAssertions.Be(System.Xml.Linq.XDocument)">

            Asserts that the current <see cref="T:System.Xml.Linq.XDocument"/> equals the <paramref name="expected"/> document,
            using its <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">The expected document</param>
        </member>
        <member name="M:FluentAssertions.Xml.XDocumentAssertions.Be(System.Xml.Linq.XDocument,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Xml.Linq.XDocument"/> equals the <paramref name="expected"/> document,
            using its <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="expected">The expected document</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XDocumentAssertions.NotBe(System.Xml.Linq.XDocument)">

            Asserts that the current <see cref="T:System.Xml.Linq.XDocument"/> does not equal the <paramref name="unexpected"/> document,
            using its <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="unexpected">The unexpected document</param>
        </member>
        <member name="M:FluentAssertions.Xml.XDocumentAssertions.NotBe(System.Xml.Linq.XDocument,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Xml.Linq.XDocument"/> does not equal the <paramref name="unexpected"/> document,
            using its <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="unexpected">The unexpected document</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XDocumentAssertions.BeNull">

            Asserts that the <see cref="T:System.Xml.Linq.XDocument"/> is <c>null</c>.

        </member>
        <member name="M:FluentAssertions.Xml.XDocumentAssertions.BeNull(System.String,System.Object[])">

            Asserts that the <see cref="T:System.Xml.Linq.XDocument"/> is <c>null</c>.

            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XDocumentAssertions.NotBeNull">

            Asserts that the <see cref="T:System.Xml.Linq.XDocument"/> is not <c>null</c>.

        </member>
        <member name="M:FluentAssertions.Xml.XDocumentAssertions.NotBeNull(System.String,System.Object[])">

            Asserts that the <see cref="T:System.Xml.Linq.XDocument"/> is not <c>null</c>.

            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XDocumentAssertions.HaveRoot(System.String)">

            Asserts that the current <see cref="T:System.Xml.Linq.XDocument"/> has a root element with the specified
            <paramref name="expected"/> name.

            <param name="expected">The name of the expected root element of the current document.</param>
        </member>
        <member name="M:FluentAssertions.Xml.XDocumentAssertions.HaveRoot(System.String,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Xml.Linq.XDocument"/> has a root element with the specified
            <paramref name="expected"/> name.

            <param name="expected">The name of the expected root element of the current document.</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XDocumentAssertions.HaveElement(System.String)">

            Asserts that the <see cref="P:System.Xml.Linq.XDocument.Root"/> element of the current <see cref="T:System.Xml.Linq.XDocument"/> has a direct
            child element with the specified <paramref name="expected"/> name.

            <param name="expected">
            The name of the expected child element of the current document's Root <see cref="P:System.Xml.Linq.XDocument.Root"/> element.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XDocumentAssertions.HaveElement(System.String,System.String,System.Object[])">

            Asserts that the <see cref="P:System.Xml.Linq.XDocument.Root"/> element of the current <see cref="T:System.Xml.Linq.XDocument"/> has a direct
            child element with the specified <paramref name="expected"/> name.

            <param name="expected">
            The name of the expected child element of the current document's Root <see cref="P:System.Xml.Linq.XDocument.Root"/> element.
            </param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Xml.XDocumentAssertions.Subject">

            Gets the object which value is being asserted.

        </member>
        <member name="T:FluentAssertions.Xml.XElementAssertions">

            Contains a number of methods to assert that an <see cref="T:System.Xml.Linq.XElement"/> is in the expected state.

        </member>
        <member name="M:FluentAssertions.Xml.XElementAssertions.#ctor(System.Xml.Linq.XElement)">

            Initializes a new instance of the <see cref="T:FluentAssertions.Xml.XElementAssertions"/> class.

        </member>
        <member name="M:FluentAssertions.Xml.XElementAssertions.Be(System.Xml.Linq.XElement)">

            Asserts that the current <see cref="T:System.Xml.Linq.XElement"/> equals the <paramref name="expected"/> element.

            <param name="expected">The expected element</param>
        </member>
        <member name="M:FluentAssertions.Xml.XElementAssertions.Be(System.Xml.Linq.XElement,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Xml.Linq.XElement"/> equals the <paramref name="expected"/> element.

            <param name="expected">The expected element</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XElementAssertions.NotBe(System.Xml.Linq.XElement)">

            Asserts that the current <see cref="T:System.Xml.Linq.XElement"/> does not equal the <paramref name="unexpected"/> element,
            using its <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="unexpected">The unexpected element</param>
        </member>
        <member name="M:FluentAssertions.Xml.XElementAssertions.NotBe(System.Xml.Linq.XElement,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Xml.Linq.XElement"/> does not equal the <paramref name="unexpected"/> element,
            using its <see cref="M:System.Object.Equals(System.Object)"/> implementation.

            <param name="unexpected">The unexpected element</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XElementAssertions.BeNull">

            Asserts that the <see cref="T:System.Xml.Linq.XElement"/> is <c>null</c>.

        </member>
        <member name="M:FluentAssertions.Xml.XElementAssertions.BeNull(System.String,System.Object[])">

            Asserts that the <see cref="T:System.Xml.Linq.XElement"/> is <c>null</c>.

            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XElementAssertions.NotBeNull">

            Asserts that the <see cref="T:System.Xml.Linq.XElement"/> is not <c>null</c>.

        </member>
        <member name="M:FluentAssertions.Xml.XElementAssertions.NotBeNull(System.String,System.Object[])">

            Asserts that the <see cref="T:System.Xml.Linq.XElement"/> is not <c>null</c>.

            <param name="reason">
            A formatted phrase explaining why the assertion should be satisfied. If the phrase does not
            start with the word because, it is prepended to the message.
            </param>
            <param name="reasonArgs">
            Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XElementAssertions.HaveAttribute(System.String,System.String)">

            Asserts that the current <see cref="T:System.Xml.Linq.XElement"/> has an attribute with the specified <paramref name="expectedName"/>
            and <paramref name="expectedValue"/>.

            <param name="expectedName">The name of the expected attribute</param>
            <param name="expectedValue">The value of the expected attribute</param>
        </member>
        <member name="M:FluentAssertions.Xml.XElementAssertions.HaveAttribute(System.String,System.String,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Xml.Linq.XElement"/> has an attribute with the specified <paramref name="expectedName"/>
            and <paramref name="expectedValue"/>.

            <param name="expectedName">The name of the expected attribute</param>
            <param name="expectedValue">The value of the expected attribute</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="M:FluentAssertions.Xml.XElementAssertions.HaveElement(System.String)">

            Asserts that the current <see cref="T:System.Xml.Linq.XElement"/> has a direct child element with the specified
            <paramref name="expected"/> name.

            <param name="expected">The name of the expected child element</param>
        </member>
        <member name="M:FluentAssertions.Xml.XElementAssertions.HaveElement(System.String,System.String,System.Object[])">

            Asserts that the current <see cref="T:System.Xml.Linq.XElement"/> has a direct child element with the specified
            <paramref name="expected"/> name.

            <param name="expected">The name of the expected child element</param>
            <param name="reason">
            A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion
            is needed. If the phrase does not start with the word because, it is prepended automatically.
            </param>
            <param name="reasonArgs">
            Zero or more objects to format using the placeholders in <see cref="!:reason"/>.
            </param>
        </member>
        <member name="P:FluentAssertions.Xml.XElementAssertions.Subject">

            Gets the object which value is being asserted.

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