From 314713c5cdc98bad2ab129edbda48519901b8c49 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ricardo=20Gro=C3=9F?= Date: Sat, 31 Oct 2026 21:10:13 +0100 Subject: [PATCH 1/3] docs: decision 128, one signature identity and a mark on every generated member Every check of a hand-written member asks C#'s identity (name, arity, parameter types without nullable annotations, by reference or by value, another kind of member of its name), the named generated members are entries the aspects introduce through and the checks read, and every generated member carries [GeneratedMember]. Measured on af3f95e; refines decisions 28 and 121. Refs #239 Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 3 +- ...ty-and-a-mark-on-every-generated-member.md | 102 ++++++++++++++++++ design/adr/README.md | 5 +- design/aspects.md | 12 +++ 4 files changed, 119 insertions(+), 3 deletions(-) create mode 100644 design/adr/0128-one-signature-identity-and-a-mark-on-every-generated-member.md diff --git a/AGENTS.md b/AGENTS.md index 4eda931..40c0602 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -159,7 +159,8 @@ the whole page. A ranked miss proves nothing. wrapped type, and no inner exception (`UnreadableInputTests`). - **Seams are declared, everything else refused.** `TryFrom`, `FromKnownGood`, `Revalidate`, `CompareTo(TSelf)` and `ToString()` written by hand are kept; any other member the generators - introduce is CMTK1011. A new generated member joins that check, or a hand-written one is kept silently. + introduce is CMTK1011. A new named generated member is introduced through its `GeneratedMembers` entry, which + that check reads; one introduced past it carries no `[GeneratedMember]`, which `GeneratedMemberAttributeTests` refuses. - **Diagnostic ids (`CMTK`) are public contract.** Never renumber a shipped rule, and never ship a new rule at Error severity in a minor version. - **A package contains this repository's code and nothing else.** Third-party code copied into `src/` or diff --git a/design/adr/0128-one-signature-identity-and-a-mark-on-every-generated-member.md b/design/adr/0128-one-signature-identity-and-a-mark-on-every-generated-member.md new file mode 100644 index 0000000..7645792 --- /dev/null +++ b/design/adr/0128-one-signature-identity-and-a-mark-on-every-generated-member.md @@ -0,0 +1,102 @@ +# 0128. One signature identity for every hand-written-member check, the generated members read from the aspects, and a mark on each + +Date: 2026-10-31 +Status: accepted + +Context: [#239](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/issues/239), under the 2.4.0 epic +[#177](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/issues/177); refines +[decision 28](0028-seams-declared-everything-else-refused.md) and +[decision 121](0121-a-generated-member-is-refused-wherever-the-value-object-reaches-it.md). Seven 2.3.1 bugs (#191, +#195, #196, #197, #205, #226, #230) were one question answered differently in several places: *is this member the +user wrote the one a generator introduces?* `ValueObjectDeclaration.MethodsWithSignature` compared parameter types +with `Equals`, `ClosedSetTypes.SameParameters` and the base-record seam walk after `ToNonNullable()`, which also turns +`int?` into `int`; `MembersNamed` took every member of a name on the value object and on its bases, while the closed +set's base walk took fields, properties and events only. The generated members' names were lists kept by hand +(`ValueObjectDeclaration.GeneratedMemberNames`, `ClosedSetTypes.GeneratedNames`), and AGENTS.md warned that a new +generated member left off them is kept silently. + +## What was measured + +On `refactor/generated-member-identity`, from `release/2.4.0` at `af3f95e`, 2026-10-31, each declaration in a +consumer of the generators at `af3f95e` and of this change, the second with warnings as errors: + +- **Another kind of member of a generated member's name.** A property or field named `Parse`, `TryFormat`, `TryFrom` or + `CompareTo`, on the value object or on a base record, failed the aspect: LAMA0506 ("there is already a property of + the same name declared in the type or in a base type"), naming nothing the user wrote. A closed set's own method + `Name()` failed inside the generated code (LAMA0611, CS0102), and a base class's nested type of the generated + converter's name failed the aspect (LAMA0531). A base class's method `All()`, beside the generated property `All`, + built: the property hides it. +- **`Nullable` read as `T`.** A base record's `TryFrom(int?)` over an `int` and a closed set's + `Parse(string, bool?)` were CMTK1011, while the value object's own `TryFrom(int?)` built, the generated + `TryFrom(int)` beside it. C# overloads the two: `int?` is `Nullable`, another type. +- **A base record's method of a generated property's or field's name** (`MinValue()`, `Value()`, `_value()`), and an + overload of an entry point of another signature (`__FromJson(string)` over an `int`), were CMTK1011. Let through, + each builds with warnings as errors, and `MinValue`, `Value`, JSON, `TryFrom` and `Parse` answer through the + generated members (a run of the built consumer printed each as expected). +- **Metalama applies no attribute to an override it writes over an implicit member.** The value object's `ToString()`, + and `Equals(TSelf)` and `GetHashCode()` over a base record, override what the record synthesizes in its own type; + Metalama writes them over that declaration, applies none of the build delegate's attributes there (the + `[CompilerGenerated]` the aspects asked for since 1.0.0 was never on them either), and refuses + `IntroduceAttribute` on it ("implicitly declared and not in an allowed category"). + +## Decision + +**One identity, C#'s** (`MemberIdentity`). A hand-written member takes a generated one's place when it is visible from +the value object (a base's private member is not: #230) and either + +- is a method with the generated method's signature: its name, its arity, and each parameter's type without its + nullable annotation and whether it is by reference (`ref`, `in` and `out` are one, by value another: CS0663). The + return type and whether it is static are not part of it. `Nullable` stays a type of its own; or +- has its name and another kind: a property, field, event or nested type beside any generated member, in the type or + a base (LAMA0506, LAMA0531); a method beside a generated property, field or nested type in the type only (CS0102), + since a base's method is hidden by it. + +The return type and static-ness stay what each *seam* is: an instance `TryFrom` is no factory, and a static +`ToString()` no seam. A seam (`TryFrom`, `FromKnownGood`, `Revalidate`, `CompareTo(TSelf)`, `ToString()`) of the +generated signature is kept, so only another kind of member of its name is refused; `CompareTo(object)` stays +CMTK1008's. The equality checks are not overload questions and keep their own rule, an `Equals` of one of the value +object's own types in either nullability (decision 75, #196), through the identity's arity and ref-kind test. + +**The generated members are read from what the aspects introduce** (`GeneratedMembers`). Each named member the +generators introduce into a value object or a closed set has one entry, its name, kind, signature, role (refused, +seam, or answered elsewhere) and contract. The aspect introduces the member through that entry, which names it, checks +that its template gives it that signature, and marks it; a template whose signature drifts from its entry fails every +build that generates it (LAMA0041 naming the member), rather than let the check look for another method. The check +reads the same entries, under the aspects' own predicates (`ResolveStrategy`, `SupportsSpan`, `SupportsUtf8`, +`HasMinMaxValue`, `DeclaresToString`), called from both sides. The names a value object or a set cannot have +(CMTK1005, CMTK1021) and the interfaces whose explicit implementations are refused are derived from the entries. Not +entries: what no check finds by its name. An explicit implementation is found by the interface mapping, an operator by +its kind, a constructor by CMTK1009 and the companion class by CMTK1007, each marked where it is introduced. + +**Every generated member carries `[GeneratedMember(typeof(Contract), "Member")]`**, a sealed attribute in +`CodoMetis.TypeKit.CompilerServices`, the Metalama-free base package: the interface the member implements +(`IParsable.Parse`), or the marker that promises it (`IValidatedValue.TryFrom`). Not +`[GeneratedCode]`, which Roslyn analyzers skip by default. `ValueObjectDeclaration.IsHandWritten` reads it beside +`[CompilerGenerated]`, and a hand-written one on a value object's or a set's member is CMTK1011, as the generators' +attributes on the type are. The exception is what Metalama cannot mark (above): a value object's `ToString()`, and +`Equals` and `GetHashCode()` over a base record, carry neither attribute, which is what they carried before. + +**The attribute and the identity are separable**, and land as two commits in that order: the identity and the +catalogue first, then the attribute, its marks and `IsHandWritten`'s reading of it. + +**What changes in a build.** Every regression row of #191 to #197, #205, #226 and #230 holds unchanged. The forms +that failed as LAMA0506, LAMA0531 or LAMA0611 above are CMTK1011 naming the member now, which breaks no build that +built. Five forms that were CMTK1011 build now: a base record's `TryFrom(int?)` over an `int`, a closed set's +`Parse(string, bool?)`, a base record's method named as a generated property or field, and an entry point's overload. +Each was a refusal of code C# compiles beside the generated member, the #230 family, and loosening an Error in a +minor is allowed by decision 34. No base type can carry a generated member today (value objects and closed sets are +sealed, and an abstract one is not generated: CMTK1006, CMTK1014, CMTK1022), so the attribute changes no check's +answer yet; it is what lets one read a member from another assembly without a name. + +Rejected: keeping each check's own rule and only sharing the names. The rules disagreed among themselves (the set's +base walk and the value object's on a base's method, `Equals` and `ToNonNullable` on `int?`), so any one shared +answer moves some of them; C#'s is the one the generated code is compiled by. Rejected too: deriving the members by +reflection over the aspect classes' templates, which read names but not the parameter types the aspects set in their +build delegates. + +`BuildOutcomeTests` holds the changed forms both ways (`A_hand_written_generated_member_is_refused_by_name`, +`What_the_generators_implement_or_attach_is_refused_by_name_on_a_set`, +`A_member_C_s_rules_keep_apart_from_the_generated_one_builds`), `GeneratedMemberAttributeTests` that every member +with `[CompilerGenerated]` carries the mark and none without it does, in this assembly and the probes', and +`GeneratedSurface.verified.txt` the contract member each names. Seeded defects in the identity, the catalogue and the +mark each fail them (the pull request lists them). diff --git a/design/adr/README.md b/design/adr/README.md index d5f04e3..a24ff83 100644 --- a/design/adr/README.md +++ b/design/adr/README.md @@ -34,7 +34,7 @@ per area ([design](../plan.md)) link to the records they rest on. | [0025](0025-analyzer-s-roslyn-floor-stays-5.md) | The analyzer's Roslyn floor stays at 5.0.0 | 2026-09-28 | accepted | | [0026](0026-value-object-s-json-wrapped-type.md) | A value object's JSON is its wrapped type's, byte for byte | 2026-09-28 | accepted | | [0027](0027-no-refusal-quotes-input.md) | No refusal quotes the input | 2026-09-28 | accepted | -| [0028](0028-seams-declared-everything-else-refused.md) | Seams are declared, everything else refused | 2026-09-28 | accepted | +| [0028](0028-seams-declared-everything-else-refused.md) | Seams are declared, everything else refused | 2026-09-28 | accepted; refined by [0128](0128-one-signature-identity-and-a-mark-on-every-generated-member.md) | | [0029](0029-only-result-terror-converts-bool.md) | Only `Result` converts to `bool` | 2026-09-28 | accepted | | [0030](0030-asynchronous-callbacks-return-task.md) | Asynchronous callbacks return `Task` | 2026-09-28 | accepted; `CatchAsync` takes a `ValueTask` by [0110](0110-catchasync-takes-a-valuetask-at-a-lower-priority.md) | | [0031](0031-no-extension-object-unconstrained-t.md) | No extension on `object` or on an unconstrained `T` | 2026-09-28 | accepted | @@ -127,9 +127,10 @@ per area ([design](../plan.md)) link to the records they rest on. | [0118](0118-an-error-may-learn-a-form-only-new-api-can-write.md) | An Error may report, in a minor version, a form that only an API new in that version can write, since no build that worked before contains it: CMTK0003's dropped assertion of `CodoMetis.TypeKit.Testing` on a `Task` or `ValueTask` in 2.3.0, its `ConfigureAwait`, `WaitAsync` and branch forms (#152) included, known by the package's assembly; the forms freeze at the tag; refines decision 34; one exception the maintainer took into 2.3.0, a dropped `Task.WhenAny` of tasks of results (#159) | 2026-10-29 | accepted; widened by [0119](0119-a-gap-found-before-the-tag-ships-in-that-release.md) | | [0119](0119-a-gap-found-before-the-tag-ships-in-that-release.md) | A form an Error misses, found before its version is tagged, is reported in that version when it loses what the rule protects in every build, though code built on the previous minor can contain it: 2.3.0's CMTK0003 on a `Task.WhenAny` of results (#159), `Wait()` on a branch (#160), an array in `Task.WaitAll`/`WaitAny` (#161), a dropped `Task.WhenEach` (#162), and a `WhenAny` of held tasks silent; the rule stops at the tag, after which decision 34 holds; refines 34 and 118 | 2026-10-29 | accepted | | [0120](0120-a-net11-0-target-and-documented-floor-raises-join-a-minor.md) | A `net11.0` target joins a 2.x minor when a feature needs it, and a dependency floor may rise in a minor, on every target or on `net11.0` alone, if it is documented (the Semantic Versioning FAQ calls a dependency update with an unchanged public API compatible; a project that references the dependency lower gets NU1605, measured on SDK 11 RC1, so the changelog names the floor, who it reaches and both ways out, and the smoke test shows it); a union new on `net11.0` is an addition and may join a 2.x minor (a `LangVersion` 14 consumer who matches on it gets CS9327, and on Metalama 2026.1 CS8652, measured); Metalama is one version for every target and TypeKit follows the maintained Metalama year in a minor: 2.3 and 2.4 stay on 2026.1 and 2.5.0 moves both targets to 2027.0 once stable (a direct 2026.1 reference gets NU1605 and stays on 2.4.x; a woven `net11.0` project goes from C# 14 to 15; conditions: a license-free CI and clean-container build, the ceiling and the 2.4.x line documented); the SDK 11 spike comes first (#170); 3.0.0 stays the `net10.0` drop and a change of an existing contract, timed to .NET 12 LTS, and .NET 11 is no reason for a major; refines decision 44 | 2026-10-29 | accepted | -| [0121](0121-a-generated-member-is-refused-wherever-the-value-object-reaches-it.md) | CMTK1011, and CMTK1008 for comparison, refuse a generated member written by hand wherever a value object or closed set reaches it: on it, in a base record, public or explicit, or as an interface's explicit implementation, in any assembly, found by the interface mapping since Metalama lists no private member of another assembly's type; a base record's `Create` beside the value object's own (#195) and a seam a base record declares (#194) too; `IConvertible`, `IValueObject<,>`, `IValueObjectMaterializer<,>`, `IPlainValueObject<,>` and a set's `IParsable` declared through an interface or by a base record are CMTK1011 where the aspect crashed (#192); a closed set's base class counts as a base record does, its `sealed` `ToString()` the seam and one not sealed refused (#205); an interface's `==` and .NET's own `INumberBase` bridges are not refused; an exception to 34 taken in the patch 2.3.1 (#191, #192, #194, #195, #197, #205) | 2026-10-30 | accepted | +| [0121](0121-a-generated-member-is-refused-wherever-the-value-object-reaches-it.md) | CMTK1011, and CMTK1008 for comparison, refuse a generated member written by hand wherever a value object or closed set reaches it: on it, in a base record, public or explicit, or as an interface's explicit implementation, in any assembly, found by the interface mapping since Metalama lists no private member of another assembly's type; a base record's `Create` beside the value object's own (#195) and a seam a base record declares (#194) too; `IConvertible`, `IValueObject<,>`, `IValueObjectMaterializer<,>`, `IPlainValueObject<,>` and a set's `IParsable` declared through an interface or by a base record are CMTK1011 where the aspect crashed (#192); a closed set's base class counts as a base record does, its `sealed` `ToString()` the seam and one not sealed refused (#205); an interface's `==` and .NET's own `INumberBase` bridges are not refused; an exception to 34 taken in the patch 2.3.1 (#191, #192, #194, #195, #197, #205) | 2026-10-30 | accepted; refined by [0128](0128-one-signature-identity-and-a-mark-on-every-generated-member.md) | | [0122](0122-arithmetic-operators-are-opt-in-and-a-hand-written-one-is-a-seam.md) | A plain value object gets the arithmetic operators (`+`, `-`, `*`, `/`, `%`, unary `-` and `+`, and their `checked` forms) of the operator interfaces it declares, where the wrapped type implements the same interface with the value object replaced by itself; each calls the wrapped type's through `GeneratedArithmetic`, a constrained generic call with its context stated; never by default and never on a validated value object, which keeps CS0535; a hand-written operator for the same operands, or an explicit implementation of the interface, its own or a base record's, is a seam, kept with its `checked` form, so 2.3 code builds unchanged; refines decision 28 | 2026-10-30 | accepted; refined by [0123](0123-a-hand-written-operator-is-refused-in-a-query.md) and [0124](0124-an-operator-in-a-query-is-the-wrapped-type-s-arithmetic.md) | | [0123](0123-a-hand-written-operator-is-refused-in-a-query.md) | An arithmetic, bitwise or shift operator a value object declares by hand is refused in an EF Core query, naming the value object and `.Value`, by an interceptor and, for query filters, when the model is built; the generated ones carry `[TranslatedAsWrappedArithmetic]`, which is what tells them apart; a conversion operator is left to EF; refines decision 122 | 2026-10-30 | accepted | | [0124](0124-an-operator-in-a-query-is-the-wrapped-type-s-arithmetic.md) | In an EF Core query, every generated arithmetic operator is rewritten to the wrapped type's operator over `ProviderValue`, which translates only through TypeKit's converter, its value-object result `Materialize`d and re-typed, never cast; `byte`, `short` and `char` operators are refused; refines decision 122, on decision 123's mark | 2026-10-30 | accepted | | [0125](0125-a-package-documents-the-third-party-code-it-contains.md) | A package carries a `THIRD-PARTY-NOTICES.txt` only when it contains third-party code (a bundled assembly, copied source, a binary release), built from the shipping closure with the license texts; a package that bundles nothing documents its own license, copyright and dependency list, and its dependencies' licenses are held to an allow-list by a conventions test, not listed (#181); no SBOM is shipped, since GitHub's export is an inventory without license data | 2026-10-30 | open | | [0126](0126-parallel-work-runs-in-worktrunk-worktrees-beside-the-repository.md) | Parallel work runs in worktrunk worktrees at `../CodoMetis.TypeKit-worktrees/`, set per machine in worktrunk's user config; worktrunk's default branch is the open `release/`, set per clone, so `wt switch -c`, the plugin's agent worktrees, `wt remove` and `wt step prune` base on it; the Bash guard refuses `wt merge` and `wt step squash`, `rebase` and `push`, since work lands by a PR and a merge commit (decision 94); nothing is copied into a new worktree, which builds the solution cold in 27 s; `.claude/worktrees/` joins `.gitignore`; [design/worktrees.md](../worktrees.md) is the runbook | 2026-10-31 | accepted | +| [0128](0128-one-signature-identity-and-a-mark-on-every-generated-member.md) | Every check of a hand-written member asks one identity, C#'s: a method of the generated one's name, arity, parameter types without nullable annotations (`Nullable` its own type) and by-reference-ness, or another kind of member of its name (in a base too, but a base's method beside a generated property), visible from the value object; the named generated members are entries the aspects introduce through, which name, check and mark them, and the check, the CMTK1005/CMTK1021 names and the refused interfaces read the same entries; every generated member carries `[GeneratedMember(typeof(Contract), "Member")]` from the base package, but the overrides Metalama writes over a record's implicit members, which take no attribute; refines decisions 28 and 121 | 2026-10-31 | accepted | diff --git a/design/aspects.md b/design/aspects.md index 77b2cf0..075ce16 100644 --- a/design/aspects.md +++ b/design/aspects.md @@ -207,6 +207,18 @@ the value object printed what a record prints and a closed set its type name, a generic or by-`in` `CompareTo(TSelf)` marked the ordering hand-written, and a generic or by-reference `TryFrom`, `Revalidate`, `CompareTo(object)`, `Equals`, `GetHashCode` or `PrintMembers` was CMTK1011 or CMTK1008. + - **One identity, and the members read from the aspects (decided 2026-10-31, [decision 128](adr/0128-one-signature-identity-and-a-mark-on-every-generated-member.md)).** + Every check of a hand-written member asks `MemberIdentity`: a method of the generated one's signature (name, + arity, parameter types without nullable annotations, `Nullable` its own type, by reference or by value), or + another kind of member of its name, visible from the value object; a base's method beside a generated property + is hidden by it and builds. The named members are `GeneratedMembers` entries, which the aspects introduce through + (naming the member, checking its template's signature, marking it) and the checks read, under the aspects' own + predicates; the CMTK1005 and CMTK1021 names and the refused interfaces come from them, not from lists. A + property or field of a generated method's name, own or a base's, failed the aspect (LAMA0506) and is CMTK1011; + a base's `TryFrom(int?)`, a set's `Parse(string, bool?)`, a base's `MinValue()` and an entry point's overload + were CMTK1011 and build. Every generated member carries `[GeneratedMember(typeof(Contract), "Member")]`, but the + overrides Metalama writes over a record's implicit `ToString()`, `Equals` and `GetHashCode()`, which take no + attribute; one written by hand is CMTK1011. - **Equality over a base record is generated (decided 2026-10-14, [decision 75](adr/0075-equality-over-base-record-generated.md)).** A derived record's synthesized equality calls the base's, which compares the base's fields and whatever the base declares. A base comparing by reference made two value objects holding 42 unequal From bf392b708031db5a09b0fea0b2148ffd7ee4ae48 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ricardo=20Gro=C3=9F?= Date: Sat, 31 Oct 2026 21:11:05 +0100 Subject: [PATCH 2/3] fix: one signature identity for every hand-written-member check, read from what the aspects introduce MethodsWithSignature, ClosedSetTypes.SameParameters, MembersNamed and the base-type walks each decided arity, ref kind, nullability and kind by rules of their own, and the generated members' names were two lists kept by hand. - MemberIdentity is C#'s: a method of the generated one's name, arity and parameter types without nullable annotations (Nullable its own type), by reference or by value; or another kind of member of its name, in the type or a base, except a base's method beside a generated property, which it hides. Visible from the value object only (#230). - GeneratedMembers holds one entry per named member the aspects introduce. Each aspect introduces through its entry, which names the member and checks that its template gives it that signature (a drift fails every build, LAMA0041); the checks, the CMTK1005/CMTK1021 names and the refused interfaces read the same entries under the aspects' own predicates. Input class: a hand-written member beside a generated one (GTS), over the shapes kind x site (own, base, base of another assembly) x signature (arity, ref kind, Nullable, annotation) x visibility, measured against af3f95e in a throwaway consumer. Siblings the unified identity found: - built now, were CMTK1011: a base record's TryFrom(int?) over an int, a closed set's Parse(string, bool?), a base record's MinValue(), Value() or _value(), an entry point's overload (each builds with warnings as errors and answers through the generated member); - CMTK1011 now, were LAMA0506/LAMA0531/LAMA0611: a property or field named Parse, TryFormat, TryFrom or CompareTo on the value object or a base, a set's Name() method, a set base's nested type of the converter's name. Every regression row of #191 to #197, #205, #226 and #230 passes unchanged. Seeded: Nullable merged into T, no cross-kind clash, visibility, ref kind and arity ignored, base methods clashing, a catalogue signature drifting, a seam found by name; each fails the generator tests. Refs #239 Defect-Class: GTS Found-By: VA Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 3 + .../ClosedSetAspect.cs | 33 +- .../ClosedSetTypes.cs | 51 +-- .../GeneratedMember.cs | 153 +++++++++ .../GeneratedMembers.cs | 308 ++++++++++++++++++ .../MemberIdentity.cs | 88 +++++ .../ValueObjectAspect.cs | 21 +- .../ValueObjectComparableAspect.cs | 24 +- .../ValueObjectContractAspect.cs | 22 +- .../ValueObjectDeclaration.cs | 212 ++++-------- .../ValueObjectFormattableAspect.cs | 28 +- .../ValueObjectJsonAspect.cs | 2 +- .../ValueObjectMinMaxValueAspect.cs | 6 +- .../ValueObjectParsableAspect.cs | 22 +- .../ValueObjectTypeConverterAspect.cs | 2 +- .../BuildOutcomeTests.cs | 88 +++++ tools/BuildVerdict/build-verdict-remedies.tsv | 2 +- 17 files changed, 772 insertions(+), 293 deletions(-) create mode 100644 src/CodoMetis.TypeKit.Generators/GeneratedMember.cs create mode 100644 src/CodoMetis.TypeKit.Generators/GeneratedMembers.cs create mode 100644 src/CodoMetis.TypeKit.Generators/MemberIdentity.cs diff --git a/CHANGELOG.md b/CHANGELOG.md index c1c7f43..70c80d1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,8 +21,11 @@ section is the GitHub release's notes. - Packages: the public surface is checked against 2.3.1's, so nothing 2.3.1 ships is removed or changed in 2.4.0. +- Generators: a property, field or nested type you wrote with the name of a generated member, on the value object, a closed set or a base of either, such as `public static int Parse => 1`, now fails with CMTK1011 naming it, where it failed with a Metalama error (LAMA0506, LAMA0531) that named nothing you wrote. So does a closed set's own method named as a generated property, such as `Name()` ([Write your own members](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.Generators/README.md#write-your-own-members)). + ### Fixed +- Generators: an overload that differs from a generated member only by a nullable value type, such as a base record's `TryFrom(int?)` over an `int` or a closed set's `Parse(string, bool?)`, a base record's method named as a generated property, such as `MinValue()`, and an overload of a private entry point are kept beside the generated member, where the build failed with CMTK1011 ([Write your own members](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.Generators/README.md#write-your-own-members)). - EF Core: a query that uses an arithmetic or bitwise operator a value object declares by hand, `&&` and `||` included, throws, naming the value object, where the database ran its own arithmetic and skipped the operator; a query filter fails when the model is built ([Queries](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries)). ## 2.3.1 — 2026-10-31 diff --git a/src/CodoMetis.TypeKit.Generators/ClosedSetAspect.cs b/src/CodoMetis.TypeKit.Generators/ClosedSetAspect.cs index cef3051..aae860a 100644 --- a/src/CodoMetis.TypeKit.Generators/ClosedSetAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ClosedSetAspect.cs @@ -1,5 +1,6 @@ using System.ComponentModel; using System.Text.Json.Serialization; +using CodoMetis.TypeKit.ClosedSets; using CodoMetis.TypeKit.CompilerServices; using Metalama.Framework.Advising; using Metalama.Framework.Aspects; @@ -119,12 +120,12 @@ public override void BuildAspect(IAspectBuilder builder) { f.Accessibility = Accessibility.Private; f.InitializerExpression = ExpressionFactory.Parse("null!"); - f.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.NameField(target).Mark(f); }); - builder.IntroduceProperty(nameof(NameTemplate), buildProperty: p => { p.Name = "Name"; p.Accessibility = Accessibility.Public; p.AddAttribute(CodeAnnotations.CompilerGenerated); }); - builder.IntroduceProperty(nameof(QualifiedNameTemplate), buildProperty: p => { p.Name = "QualifiedName"; p.Accessibility = Accessibility.Public; p.AddAttribute(CodeAnnotations.CompilerGenerated); }); + builder.IntroduceProperty(nameof(NameTemplate), buildProperty: p => { p.Accessibility = Accessibility.Public; GeneratedMembers.Name(target).Mark(p); }); + builder.IntroduceProperty(nameof(QualifiedNameTemplate), buildProperty: p => { p.Accessibility = Accessibility.Public; GeneratedMembers.QualifiedName(target).Mark(p); }); if (!ClosedSetTypes.DeclaresToString(target)) - builder.IntroduceMethod(nameof(ToStringTemplate), IntroductionScope.Instance, OverrideStrategy.Override, m => { m.Name = "ToString"; m.AddAttribute(CodeAnnotations.CompilerGenerated); }); + builder.IntroduceMethod(nameof(ToStringTemplate), IntroductionScope.Instance, OverrideStrategy.Override, m => GeneratedMembers.SetToString(target).Mark(m)); builder.AddInitializer(nameof(NamesInitializerTemplate), InitializerKind.BeforeTypeConstructor); @@ -139,47 +140,42 @@ public override void BuildAspect(IAspectBuilder builder) f.Type = listType; f.Writeability = Writeability.ConstructorOnly; f.InitializerExpression = ExpressionFactory.Parse("null!"); - f.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.AllField(target).Mark(f); }); builder.IntroduceProperty(nameof(AllTemplate), buildProperty: p => { - p.Name = "All"; p.Type = listType; p.Accessibility = Accessibility.Public; p.IsStatic = true; - p.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.All(target).Mark(p); }); builder.IntroduceMethod(nameof(TryParseTemplate), IntroductionScope.Static, OverrideStrategy.Fail, m => { - m.Name = "TryParse"; m.Accessibility = Accessibility.Public; m.Parameters[1].Type = target.ToNullable(); - m.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.SetTryParse(target, ignoreCase: false).Mark(m); }); builder.IntroduceMethod(nameof(ParseTemplate), IntroductionScope.Static, OverrideStrategy.Fail, m => { - m.Name = "Parse"; m.Accessibility = Accessibility.Public; m.ReturnType = target; - m.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.SetParse(target, ignoreCase: false).Mark(m); }); // The same two with ignoreCase, opted into at the call: JSON, the column, binding and // IParsable stay ordinal, since what is stored or sent is the name as it is. builder.IntroduceMethod(nameof(TryParseIgnoreCaseTemplate), IntroductionScope.Static, OverrideStrategy.Fail, m => { - m.Name = "TryParse"; m.Accessibility = Accessibility.Public; m.Parameters[2].Type = target.ToNullable(); - m.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.SetTryParse(target, ignoreCase: true).Mark(m); }); builder.IntroduceMethod(nameof(ParseIgnoreCaseTemplate), IntroductionScope.Static, OverrideStrategy.Fail, m => { - m.Name = "Parse"; m.Accessibility = Accessibility.Public; m.ReturnType = target; - m.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.SetParse(target, ignoreCase: true).Mark(m); }); // IParsable, explicitly: Parse(string) and TryParse(string, out) are the set's own @@ -200,12 +196,11 @@ public override void BuildAspect(IAspectBuilder builder) builder.IntroduceMethod(nameof(MatchTemplate), IntroductionScope.Instance, OverrideStrategy.Fail, m => { - m.Name = "Match"; m.Accessibility = Accessibility.Public; - m.AddAttribute(CodeAnnotations.CompilerGenerated); var func = m.Parameters[0].Type; m.Parameters[0].Name = ClosedSetTypes.ParameterName(members[0]); foreach (var member in members.Skip(1)) m.AddParameter(ClosedSetTypes.ParameterName(member), func); + GeneratedMembers.Match(target, members.Count).Mark(m); }); var converter = builder.IntroduceClass($"{target.Name}JsonConverter", buildType: t => @@ -214,7 +209,7 @@ public override void BuildAspect(IAspectBuilder builder) t.BaseType = TypeFactory.GetNamedType(typeof(JsonConverter<>)).WithTypeArguments(target); t.IsStatic = false; t.IsSealed = true; - t.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.SetJsonConverter(target).Mark(t); }); converter.IntroduceMethod(nameof(JsonReadTemplate), IntroductionScope.Instance, OverrideStrategy.Override, m => { m.Name = "Read"; m.ReturnType = target; m.AddAttribute(CodeAnnotations.CompilerGenerated); }); converter.IntroduceMethod(nameof(JsonWriteTemplate), IntroductionScope.Instance, OverrideStrategy.Override, m => { m.Name = "Write"; m.Parameters[1].Type = target; m.AddAttribute(CodeAnnotations.CompilerGenerated); }); @@ -229,7 +224,7 @@ public override void BuildAspect(IAspectBuilder builder) t.BaseType = TypeFactory.GetNamedType(typeof(TypeConverter)); t.IsStatic = false; t.IsSealed = true; - t.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.SetTypeConverter(target).Mark(t); }); typeConverter.IntroduceMethod(nameof(CanConvertFromTemplate), IntroductionScope.Instance, OverrideStrategy.Override, m => { m.Name = nameof(TypeConverter.CanConvertFrom); m.AddAttribute(CodeAnnotations.CompilerGenerated); }); typeConverter.IntroduceMethod(nameof(CanConvertToTemplate), IntroductionScope.Instance, OverrideStrategy.Override, m => { m.Name = nameof(TypeConverter.CanConvertTo); m.AddAttribute(CodeAnnotations.CompilerGenerated); }); diff --git a/src/CodoMetis.TypeKit.Generators/ClosedSetTypes.cs b/src/CodoMetis.TypeKit.Generators/ClosedSetTypes.cs index 41d6c12..27d7af0 100644 --- a/src/CodoMetis.TypeKit.Generators/ClosedSetTypes.cs +++ b/src/CodoMetis.TypeKit.Generators/ClosedSetTypes.cs @@ -30,9 +30,12 @@ public static string NestingChain(INamedType set) => public static string AllExpression(INamedType set, IReadOnlyList members) => $"global::System.Array.AsReadOnly(new {ValueObjectTypes.SourceName(set)}[] {{ {string.Join(", ", members.Select(member => $"{ValueObjectTypes.SourceName(set)}.{member.Name}"))} }})"; - /// The names of what the generators introduce into the set itself; nothing else in it may have one (CMTK1011, CMTK1021). + /// + /// The names of what the generators introduce into the set itself, read from what they introduce + /// (); nothing else in it may have one (CMTK1011, CMTK1021). + /// public static IReadOnlyList GeneratedNames(INamedType set) => - ["Name", "QualifiedName", "All", "Match", "Parse", "TryParse", "ToString", "_name", "_all", $"{set.Name}JsonConverter", $"{set.Name}TypeConverter"]; + [.. GeneratedMembers.OfClosedSet(set, Members(set).Count, everyCondition: true).Select(member => member.Name).Distinct()]; /// /// The name of 's parameter of Match: its own, with the first letter @@ -203,28 +206,18 @@ private static string WithoutComments(string text) /// public static IReadOnlyList GeneratedMembersDeclaredByHand(INamedType set, IReadOnlyList members) { - (IType, bool) text = (TypeFactory.GetType(SpecialType.String), false); - (IType, bool) boolean = (TypeFactory.GetType(SpecialType.Boolean), false); - (IType, bool) result = (set, true); var parsable = TypeFactory.GetNamedType(typeof(IParsable<>)).WithTypeArguments(set); - var memberNames = new HashSet(members.Select(member => member.ToDisplayString())); - var generatedNames = GeneratedNames(set); var bases = ValueObjectDeclaration.SelfAndBases(set).Skip(1).ToList(); - IEnumerable Declared(Func> find) => - ValueObjectDeclaration.SelfAndBases(set).SelectMany(type => find(type).Where(method => method.IsAccessibleFrom(set)).Select(method => type.Equals(set) - ? ValueObjectDeclaration.Describe(method) - : $"{ValueObjectDeclaration.Describe(method)} in its base type {type.ToDisplayString()}")); - + // By what the aspect introduces and C#'s overloading rules (MemberIdentity, decision 128). The set's own + // members are CMTK1021's, which says to rename them. List found = [ - .. ValueObjectDeclaration.MembersNamed(set, methods: false, [.. generatedNames]).Where(declared => !memberNames.Contains(declared)), - .. bases.SelectMany(type => type.Fields.Concat(type.Properties).Concat(type.Events) - .Where(member => member is { IsImplicitlyDeclared: false, IsExplicitInterfaceImplementation: false } && member.IsAccessibleFrom(set) && generatedNames.Contains(member.Name)) - .Select(member => $"{member.ToDisplayString()} in its base type {type.ToDisplayString()}")), - .. Declared(type => type.Methods.Where(method => IsOwn(method) && method.Name == "Parse" && (SameParameters(method, text) || SameParameters(method, text, boolean)))), - .. Declared(type => type.Methods.Where(method => IsOwn(method) && method.Name == "TryParse" && (SameParameters(method, text, result) || SameParameters(method, text, boolean, result)))), - .. Declared(type => type.Methods.Where(method => IsOwn(method) && IsGeneratedMatch(method, members.Count))), + .. GeneratedMembers.OfClosedSet(set, members.Count) + .SelectMany(generated => ValueObjectDeclaration.SelfAndBases(set) + .SelectMany(type => MemberIdentity.DeclaredInItsPlace(type, set, generated) + .Where(declared => !(declared is IField field && members.Contains(field))) + .Select(declared => ValueObjectDeclaration.DescribeDeclared(declared) + (type.Equals(set) ? "" : $" in its base type {type.ToDisplayString()}")))), .. ValueObjectDeclaration.ImplementationsOf(set, [TypeFactory.GetNamedType(typeof(IClosedSet<>))]), .. set.ImplementedInterfaces.Where(implemented => implemented.Equals(parsable)).Select(implemented => $"the interface {implemented.ToDisplayString()}"), .. set.ImplementedInterfaces.Where(implemented => implemented.AllImplementedInterfaces.Any(inherited => inherited.Equals(parsable))).Select(implemented => $"the interface {parsable.ToDisplayString()} in its interface {implemented.ToDisplayString()}"), @@ -242,26 +235,6 @@ .. set.Attributes.Where(attribute => attribute.Type.Equals(TypeFactory.GetNamedT ]; } - private static bool IsOwn(IMethod method) => method is { IsImplicitlyDeclared: false, IsExplicitInterfaceImplementation: false }; - - /// - /// Parameter types equal, nullability aside, and each by reference where the generated one is out, in a - /// method without type parameters: Metalama refuses to introduce a method beside one of the same signature. A - /// generic Parse<T>(string) or a TryParse(string?, TSelf) is another method (#226). - /// - private static bool SameParameters(IMethod method, params (IType Type, bool Out)[] parameters) => - method.TypeParameters.Count == 0 - && method.Parameters.Count == parameters.Length - && method.Parameters.Zip(parameters, (declared, expected) => declared.Type.ToNonNullable().Equals(expected.Type.ToNonNullable()) && declared.RefKind != RefKind.None == expected.Out).All(same => same); - - /// The generated Match<TResult>: one Func<TResult> per member. - private static bool IsGeneratedMatch(IMethod method, int memberCount) => - method is { Name: "Match", TypeParameters.Count: 1 } - && method.Parameters.Count == memberCount - && method.Parameters.All(parameter => parameter.Type is INamedType { IsGeneric: true } func - && func.Definition.Equals(TypeFactory.GetNamedType(typeof(Func<>))) - && func.TypeArguments[0].Equals(method.TypeParameters[0])); - /// /// Whether a ToString() is written by hand: the seam, kept in place of the generated one. A base class's /// sealed one is the seam too, as for a value object: C# keeps it in every derived class, and generating diff --git a/src/CodoMetis.TypeKit.Generators/GeneratedMember.cs b/src/CodoMetis.TypeKit.Generators/GeneratedMember.cs new file mode 100644 index 0000000..fb130a3 --- /dev/null +++ b/src/CodoMetis.TypeKit.Generators/GeneratedMember.cs @@ -0,0 +1,153 @@ +using Metalama.Framework.Aspects; +using Metalama.Framework.Code; +using Metalama.Framework.Code.DeclarationBuilders; + +namespace CodoMetis.TypeKit.Generators; + +/// What a generated member is, for the check of a hand-written one beside it. +[CompileTime] +internal enum GeneratedMemberKind +{ + Method, + Property, + Field, + NestedType +} + +/// What a hand-written member of a generated method's signature is. +[CompileTime] +internal enum GeneratedMemberRole +{ + /// CMTK1011: the generators introduce it themselves. + Refused, + + /// Kept in place of the generated one: TryFrom, FromKnownGood, Revalidate, CompareTo(TSelf), ToString(). + Seam, + + /// Answered by a rule of its own: CompareTo(object) by CMTK1008, a record's equality by the equality checks. + Elsewhere +} + +/// +/// A parameter of a generated method: its type, or a test for it where the type depends on the method (a +/// Func<TResult> of Match's own type parameter), and whether it is by reference. +/// +[CompileTime] +internal sealed class GeneratedParameter +{ + private readonly IType? _type; + private readonly Func? _matches; + + private GeneratedParameter(IType? type, Func? matches, bool byReference) + { + _type = type; + _matches = matches; + ByReference = byReference; + } + + public bool ByReference { get; } + + public static GeneratedParameter Of(IType type) => new(type, null, byReference: false); + + public static GeneratedParameter Out(IType type) => new(type, null, byReference: true); + + public static GeneratedParameter Matching(Func matches) => new(null, matches, byReference: false); + + public bool Matches(IParameter parameter, IMethod method) => + parameter.RefKind != RefKind.None == ByReference + && (_type is not null ? MemberIdentity.SameType(parameter.Type, _type) : _matches!(parameter.Type, method)); +} + +/// +/// One member the generators introduce: its name, kind and signature, which both its introduction and the check +/// of a hand-written member beside it read, and the contract it implements (decision 128). Made by +/// . +/// +[CompileTime] +internal sealed class GeneratedMember +{ + internal GeneratedMember(string name, GeneratedMemberKind kind, GeneratedMemberRole role, INamedType contract, string contractMember, int arity = 0, IReadOnlyList? parameters = null, bool clashesByName = true) + { + Name = name; + Kind = kind; + Role = role; + Contract = contract; + ContractMember = contractMember; + Arity = arity; + Parameters = parameters ?? []; + ClashesByName = clashesByName; + } + + public string Name { get; } + + public GeneratedMemberKind Kind { get; } + + public GeneratedMemberRole Role { get; } + + /// The interface the member implements, or the marker that promises it. + public INamedType Contract { get; } + + /// The contract member's name, or the generated member's own where the contract declares none. + public string ContractMember { get; } + + public int Arity { get; } + + public IReadOnlyList Parameters { get; } + + /// + /// A member of its name of another kind takes its place. Not for a value object's ToString: a record + /// synthesizes ToString(), and a property of that name is C#'s own error. + /// + public bool ClashesByName { get; } + + public bool HasSignatureOf(IMethod method) => MemberIdentity.HasSignature(method, Name, Arity, Parameters); + + /// + /// Names the introduced method, checks that its template gives it this signature, and marks it. Called last in + /// the build delegate, once the aspect has set the parameter types: a template whose signature drifted from + /// this one fails every build that generates it, rather than let the check look for another method. + /// + public void Mark(IMethodBuilder method) + { + method.Name = Name; + + if (Kind != GeneratedMemberKind.Method || !HasSignatureOf(method)) + throw new InvalidOperationException($"The generated {Name} has the signature {method.ToDisplayString()}, which is not the one GeneratedMembers declares for it."); + + AddAttributes(method); + } + + /// + public void Mark(IPropertyBuilder property) + { + property.Name = Name; + + if (Kind != GeneratedMemberKind.Property) + throw new InvalidOperationException($"The generated {Name} is a property, which GeneratedMembers does not declare it as."); + + AddAttributes(property); + } + + /// Checks that the introduced field has this name, and marks it. + public void Mark(IFieldBuilder field) + { + if (Kind != GeneratedMemberKind.Field || field.Name != Name) + throw new InvalidOperationException($"The generated field {field.Name} is not the {Name} GeneratedMembers declares."); + + AddAttributes(field); + } + + /// Checks that the introduced nested type has this name, and marks it. + public void Mark(INamedTypeBuilder type) + { + if (Kind != GeneratedMemberKind.NestedType || type.Name != Name) + throw new InvalidOperationException($"The generated type {type.Name} is not the {Name} GeneratedMembers declares."); + + AddAttributes(type); + } + + private void AddAttributes(IDeclarationBuilder declaration) + { + declaration.AddAttribute(CodeAnnotations.CompilerGenerated); + } +} diff --git a/src/CodoMetis.TypeKit.Generators/GeneratedMembers.cs b/src/CodoMetis.TypeKit.Generators/GeneratedMembers.cs new file mode 100644 index 0000000..316206f --- /dev/null +++ b/src/CodoMetis.TypeKit.Generators/GeneratedMembers.cs @@ -0,0 +1,308 @@ +using System.Numerics; +using CodoMetis.TypeKit.ClosedSets; +using CodoMetis.TypeKit.ValueObjects; +using Metalama.Framework.Aspects; +using Metalama.Framework.Code; +using static CodoMetis.TypeKit.Generators.GeneratedParameter; + +namespace CodoMetis.TypeKit.Generators; + +/// +/// The named members the generators introduce into a value object or a closed set (decision 128). Each aspect +/// introduces a member through the entry made here, which names it, checks its template's signature and marks +/// it; the check of a hand-written member reads the same entries, under the conditions the aspects decide by. +/// What the generators introduce and what the check looks for cannot drift apart, as two name lists kept in step +/// by hand did. +/// +/// +/// +/// Not here: what no check finds by its name. An explicit implementation (the materializer, IConvertible, +/// a closed set's IParsable<TSelf>) is found by the interface mapping, an operator by its kind, a +/// constructor by CMTK1009, and the companion class by CMTK1007, each by +/// its own check. Neither are the members a record +/// synthesizes and the generators replace (Equals, GetHashCode), which the equality checks answer. +/// +/// +/// Every entry is made where it is used, never kept in a static field: its types belong to one compilation +/// (CompileTimeStaticStateTests). +/// +/// +[CompileTime] +internal static class GeneratedMembers +{ + // ValueObjectAspect. + + public static GeneratedMember ValueField(INamedType target, IType valueType) => + new("_value", GeneratedMemberKind.Field, GeneratedMemberRole.Refused, ValueObject(target, valueType), nameof(IValueObject<,>.Value)); + + /// __FromJson(T value, bool materialize): the JSON converter's way in. + public static GeneratedMember FromJson(INamedType target, IType valueType, INamedType marker) => + Method("__FromJson", Construction(target, valueType, marker), [Of(valueType), Of(TypeFactory.GetType(SpecialType.Boolean))]); + + /// __FromText(T value): parsing's and the type converter's way in. + public static GeneratedMember FromText(INamedType target, IType valueType, INamedType marker) => + Method("__FromText", Construction(target, valueType, marker), [Of(valueType)]); + + /// __TryFromText(T value, out TSelf result): TryParse's way in. + public static GeneratedMember TryFromText(INamedType target, IType valueType, INamedType marker) => + Method("__TryFromText", Construction(target, valueType, marker), [Of(valueType), Out(target)]); + + // ValueObjectContractAspect. + + public static GeneratedMember Value(INamedType target, IType valueType) => + new(nameof(IValueObject<,>.Value), GeneratedMemberKind.Property, GeneratedMemberRole.Refused, ValueObject(target, valueType), nameof(IValueObject<,>.Value)); + + public static GeneratedMember From(INamedType target, IType valueType) => + Method(nameof(IPlainValueObject<,>.From), PlainValueObject(target, valueType), [Of(valueType)], contractMember: nameof(IPlainValueObject<,>.From)); + + public static GeneratedMember TryFrom(IType valueType, INamedType marker) => + Method("TryFrom", marker, [Of(valueType)], GeneratedMemberRole.Seam); + + /// FromKnownGood(T value, string? source), whose second parameter the compiler fills with the caller's expression. + public static GeneratedMember FromKnownGood(IType valueType, INamedType marker) => + Method("FromKnownGood", marker, [Of(valueType), Of(TypeFactory.GetType(SpecialType.String))], GeneratedMemberRole.Seam); + + public static GeneratedMember Revalidate(INamedType marker) => + Method("Revalidate", marker, [], GeneratedMemberRole.Seam); + + /// Equals(TSelf?) over the wrapped value, for a record class with a base, which the record synthesizes otherwise. + public static GeneratedMember RecordEquals(INamedType target) => + Method(nameof(Equals), Equatable(target), [Of(target)], GeneratedMemberRole.Elsewhere, clashesByName: false); + + public static GeneratedMember RecordGetHashCode(INamedType target) => + Method(nameof(GetHashCode), Equatable(target), [], GeneratedMemberRole.Elsewhere, clashesByName: false); + + /// new Equals(TBase?), which takes a deeper base's IEquatable<TBase> over (decision 87). + public static GeneratedMember ReimplementedEquals(INamedType hidden) => + Method(nameof(Equals), Equatable(hidden), [Of(hidden)], GeneratedMemberRole.Elsewhere, clashesByName: false); + + // ValueObjectParsableAspect and ValueObjectTypeConverterAspect. + + /// Parse(text, IFormatProvider?), where is string, ReadOnlySpan<char> or ReadOnlySpan<byte>. + public static GeneratedMember Parse(INamedType target, IType text) => + Method(nameof(IParsable<>.Parse), Parsable(target, text), [Of(text), Of(Provider)]); + + public static GeneratedMember TryParse(INamedType target, IType text) => + Method(nameof(IParsable<>.TryParse), Parsable(target, text), [Of(text), Of(Provider), Out(target)]); + + public static GeneratedMember TypeConverter(INamedType target, INamedType marker) => + new($"{target.Name}TypeConverter", GeneratedMemberKind.NestedType, GeneratedMemberRole.Refused, marker, $"{target.Name}TypeConverter"); + + // ValueObjectJsonAspect. + + public static GeneratedMember JsonConverter(INamedType target, INamedType marker) => + new($"{target.Name}JsonConverter", GeneratedMemberKind.NestedType, GeneratedMemberRole.Refused, marker, $"{target.Name}JsonConverter"); + + // ValueObjectFormattableAspect. + + public static GeneratedMember FormattableToString() => + Method(nameof(IFormattable.ToString), TypeFactory.GetNamedType(typeof(IFormattable)), [Of(TypeFactory.GetType(SpecialType.String)), Of(Provider)], clashesByName: false); + + /// The override of the record's ToString(), the seam. + public static GeneratedMember ToStringOverride(INamedType target, IType valueType) => + Method(nameof(ToString), ValueObject(target, valueType), [], GeneratedMemberRole.Seam, clashesByName: false); + + public static GeneratedMember TryFormat() => + Method(nameof(ISpanFormattable.TryFormat), TypeFactory.GetNamedType(typeof(ISpanFormattable)), + [Of(TypeFactory.GetType(typeof(Span))), Out(TypeFactory.GetType(SpecialType.Int32)), Of(TypeFactory.GetType(typeof(ReadOnlySpan))), Of(Provider)]); + + public static GeneratedMember TryFormatUtf8() => + Method(nameof(IUtf8SpanFormattable.TryFormat), TypeFactory.GetNamedType(typeof(IUtf8SpanFormattable)), + [Of(TypeFactory.GetType(typeof(Span))), Out(TypeFactory.GetType(SpecialType.Int32)), Of(TypeFactory.GetType(typeof(ReadOnlySpan))), Of(Provider)]); + + // ValueObjectMinMaxValueAspect. + + public static GeneratedMember MinValue(INamedType target) => + new(nameof(IMinMaxValue<>.MinValue), GeneratedMemberKind.Property, GeneratedMemberRole.Refused, MinMaxValue(target), nameof(IMinMaxValue<>.MinValue)); + + public static GeneratedMember MaxValue(INamedType target) => + new(nameof(IMinMaxValue<>.MaxValue), GeneratedMemberKind.Property, GeneratedMemberRole.Refused, MinMaxValue(target), nameof(IMinMaxValue<>.MaxValue)); + + // ValueObjectComparableAspect. + + /// CompareTo(TSelf), the comparison seam. + public static GeneratedMember CompareTo(INamedType target) => + Method(nameof(IComparable<>.CompareTo), TypeFactory.GetNamedType(typeof(IComparable<>)).WithTypeArguments(target), [Of(target)], GeneratedMemberRole.Seam); + + /// CompareTo(object?); a hand-written one is CMTK1008. + public static GeneratedMember ObjectCompareTo() => + Method(nameof(IComparable.CompareTo), TypeFactory.GetNamedType(typeof(IComparable)), [Of(TypeFactory.GetType(SpecialType.Object))], GeneratedMemberRole.Elsewhere); + + /// + /// The named members the generators introduce into , under the conditions the aspects + /// introduce them by: each aspect's own predicate, called here as there. + /// + public static IReadOnlyList OfValueObject(INamedType target, INamedType valueType, ValueObjectKind kind) => + Catalogue(target, valueType, ValueObjectTypes.Markers(target)[0], kind, everyCondition: false); + + /// + /// The names of the members the generators introduce into a value object for some marker or wrapped type, + /// which a value object cannot have (CS0542). Not those declares, ToString and + /// Equals, which a record synthesizes, so that a value object of that name is C#'s own error. + /// + public static IReadOnlyList NamesInAnyValueObject(INamedType target, INamedType marker) + { + var objectMembers = new HashSet(TypeFactory.GetNamedType(typeof(object)).Methods.Select(method => method.Name)); + var valueType = ValueObjectTypes.WrappedType(marker); + + return + [ + .. new[] { ValueObjectKind.Plain, ValueObjectKind.Validated } + .SelectMany(kind => Catalogue(target, valueType, marker, kind, everyCondition: true)) + .Select(member => member.Name) + .Where(name => !objectMembers.Contains(name)) + .Distinct() + ]; + } + + private static IReadOnlyList Catalogue(INamedType target, IType valueType, INamedType marker, ValueObjectKind kind, bool everyCondition) + { + var named = valueType as INamedType; + + bool When(Func condition) => everyCondition || (named is not null && condition(named)); + + List members = [ValueField(target, valueType), FromJson(target, valueType, marker), FromText(target, valueType, marker), TryFromText(target, valueType, marker), Value(target, valueType), JsonConverter(target, marker)]; + + if (kind == ValueObjectKind.Plain) + members.Add(From(target, valueType)); + else + members.AddRange([TryFrom(valueType, marker), FromKnownGood(valueType, marker), Revalidate(marker)]); + + if (When(type => ValueObjectParsableAspect.ResolveStrategy(type) != ValueParseStrategy.Unsupported)) + { + members.AddRange([Parse(target, Text), TryParse(target, Text), TypeConverter(target, marker)]); + + if (When(ValueObjectParsableAspect.SupportsSpan)) + members.AddRange([Parse(target, Span), TryParse(target, Span)]); + + if (When(ValueObjectParsableAspect.SupportsUtf8)) + members.AddRange([Parse(target, Utf8), TryParse(target, Utf8)]); + } + + if (everyCondition || !ValueObjectDeclaration.DeclaresToString(target)) + { + members.AddRange([FormattableToString(), ToStringOverride(target, valueType)]); + + if (When(type => ValueObjectFormattableAspect.ResolveStrategy(type) == ValueFormatStrategy.SpanFormattable)) + members.Add(TryFormat()); + + if (When(ValueObjectFormattableAspect.SupportsUtf8)) + members.Add(TryFormatUtf8()); + } + + if (kind == ValueObjectKind.Plain && When(ValueObjectMinMaxValueAspect.HasMinMaxValue)) + members.AddRange([MinValue(target), MaxValue(target)]); + + if (When(type => ValueObjectComparableAspect.ResolveStrategy(type) != ValueCompareStrategy.Unsupported)) + members.AddRange([CompareTo(target), ObjectCompareTo()]); + + return members; + } + + // ClosedSetAspect. + + public static GeneratedMember NameField(INamedType set) => + new("_name", GeneratedMemberKind.Field, GeneratedMemberRole.Refused, ClosedSet(set), nameof(IClosedSet<>.Name)); + + public static GeneratedMember Name(INamedType set) => + new(nameof(IClosedSet<>.Name), GeneratedMemberKind.Property, GeneratedMemberRole.Refused, ClosedSet(set), nameof(IClosedSet<>.Name)); + + public static GeneratedMember QualifiedName(INamedType set) => + new(nameof(IClosedSet<>.QualifiedName), GeneratedMemberKind.Property, GeneratedMemberRole.Refused, ClosedSet(set), nameof(IClosedSet<>.QualifiedName)); + + public static GeneratedMember AllField(INamedType set) => + new("_all", GeneratedMemberKind.Field, GeneratedMemberRole.Refused, ClosedSet(set), nameof(IClosedSet<>.All)); + + public static GeneratedMember All(INamedType set) => + new(nameof(IClosedSet<>.All), GeneratedMemberKind.Property, GeneratedMemberRole.Refused, ClosedSet(set), nameof(IClosedSet<>.All)); + + /// TryParse(string?, out TSelf), or with bool ignoreCase before the result. + public static GeneratedMember SetTryParse(INamedType set, bool ignoreCase) => + Method(nameof(IClosedSet<>.TryParse), ClosedSet(set), ignoreCase ? [Of(Text), Of(Boolean), Out(set)] : [Of(Text), Out(set)]); + + /// Parse(string), or Parse(string, bool ignoreCase). + public static GeneratedMember SetParse(INamedType set, bool ignoreCase) => + Method("Parse", ClosedSet(set), ignoreCase ? [Of(Text), Of(Boolean)] : [Of(Text)]); + + /// Match<TResult>: one Func<TResult> of its own type parameter per member. + public static GeneratedMember Match(INamedType set, int memberCount) => + Method("Match", ClosedSet(set), [.. Enumerable.Repeat(Matching(IsFuncOfOwnTypeParameter), memberCount)], arity: 1); + + /// The set's ToString(), the seam. + public static GeneratedMember SetToString(INamedType set) => + Method(nameof(ToString), ClosedSet(set), [], GeneratedMemberRole.Seam); + + public static GeneratedMember SetJsonConverter(INamedType set) => + new($"{set.Name}JsonConverter", GeneratedMemberKind.NestedType, GeneratedMemberRole.Refused, ClosedSet(set), $"{set.Name}JsonConverter"); + + public static GeneratedMember SetTypeConverter(INamedType set) => + new($"{set.Name}TypeConverter", GeneratedMemberKind.NestedType, GeneratedMemberRole.Refused, ClosedSet(set), $"{set.Name}TypeConverter"); + + /// + /// The named members introduces into of + /// members: ToString() unless the set declares it, when + /// is false. + /// + public static IReadOnlyList OfClosedSet(INamedType set, int memberCount, bool everyCondition = false) + { + List members = + [ + NameField(set), Name(set), QualifiedName(set), AllField(set), All(set), + SetTryParse(set, ignoreCase: false), SetParse(set, ignoreCase: false), SetTryParse(set, ignoreCase: true), SetParse(set, ignoreCase: true), + Match(set, memberCount), SetJsonConverter(set), SetTypeConverter(set) + ]; + + if (everyCondition || !ClosedSetTypes.DeclaresToString(set)) + members.Add(SetToString(set)); + + return members; + } + + /// + /// The method's type parameter is read by its kind and position: in the method the aspect builds, the + /// parameters' Func<TResult> is bound to the template's TResult, which Metalama 2026.1 copies + /// rather than rebinding to the builder's own (spikes/ClosedSets). + /// + private static bool IsFuncOfOwnTypeParameter(IType type, IMethod method) => + type is INamedType { IsGeneric: true } func + && func.Definition.Equals(TypeFactory.GetNamedType(typeof(Func<>))) + && method.TypeParameters.Count == 1 + && func.TypeArguments[0] is ITypeParameter { TypeParameterKind: TypeParameterKind.Method, Index: 0 }; + + private static GeneratedMember Method(string name, INamedType contract, IReadOnlyList parameters, GeneratedMemberRole role = GeneratedMemberRole.Refused, string? contractMember = null, int arity = 0, bool clashesByName = true) => + new(name, GeneratedMemberKind.Method, role, contract, contractMember ?? name, arity, parameters, clashesByName); + + private static IType Text => TypeFactory.GetType(SpecialType.String); + + private static IType Span => TypeFactory.GetType(typeof(ReadOnlySpan)); + + private static IType Utf8 => TypeFactory.GetType(typeof(ReadOnlySpan)); + + private static IType Boolean => TypeFactory.GetType(SpecialType.Boolean); + + private static IType Provider => TypeFactory.GetType(typeof(IFormatProvider)); + + private static INamedType ValueObject(INamedType target, IType valueType) => + TypeFactory.GetNamedType(typeof(IValueObject<,>)).WithTypeArguments(target, valueType); + + private static INamedType PlainValueObject(INamedType target, IType valueType) => + TypeFactory.GetNamedType(typeof(IPlainValueObject<,>)).WithTypeArguments(target, valueType); + + /// What the entry points construct by: From of a plain value object, Create of a validated one. + public static INamedType Construction(INamedType target, IType valueType, INamedType marker) => + ValueObjectTypes.KindOf(marker) == ValueObjectKind.Plain ? PlainValueObject(target, valueType) : marker; + + /// From or Create, the member of the entry points and the private constructor serve. + public static string ConstructionMember(INamedType marker) => + ValueObjectTypes.KindOf(marker) == ValueObjectKind.Plain ? nameof(IPlainValueObject<,>.From) : nameof(IValidatedValue<,,>.Create); + + private static INamedType Equatable(INamedType type) => TypeFactory.GetNamedType(typeof(IEquatable<>)).WithTypeArguments(type); + + private static INamedType MinMaxValue(INamedType target) => TypeFactory.GetNamedType(typeof(IMinMaxValue<>)).WithTypeArguments(target); + + private static INamedType ClosedSet(INamedType set) => TypeFactory.GetNamedType(typeof(IClosedSet<>)).WithTypeArguments(set); + + /// IParsable<TSelf>, ISpanParsable<TSelf> or IUtf8SpanParsable<TSelf>, by the text it parses. + private static INamedType Parsable(INamedType target, IType text) => + TypeFactory.GetNamedType(text.Equals(Text) ? typeof(IParsable<>) : text.Equals(Span) ? typeof(ISpanParsable<>) : typeof(IUtf8SpanParsable<>)).WithTypeArguments(target); +} diff --git a/src/CodoMetis.TypeKit.Generators/MemberIdentity.cs b/src/CodoMetis.TypeKit.Generators/MemberIdentity.cs new file mode 100644 index 0000000..0284207 --- /dev/null +++ b/src/CodoMetis.TypeKit.Generators/MemberIdentity.cs @@ -0,0 +1,88 @@ +using Metalama.Framework.Aspects; +using Metalama.Framework.Code; + +namespace CodoMetis.TypeKit.Generators; + +/// +/// The one answer to "is this member the user wrote the one a generator introduces?", for every check of a +/// hand-written member (decision 128): C#'s overloading rules, and what Metalama refuses to introduce beside. +/// +/// +/// +/// A method's signature is its name, its arity, and each parameter's type without its nullable annotation and +/// whether it is by reference: a generic Parse<TFormat>(string, IFormatProvider?), a +/// From(in int) and a TryParse whose last parameter is by value are other methods, which the +/// generated ones sit beside (#226). ref or in against out is no overload in C# (CS0663), +/// and nullability none at all, so both are the same method. int? is Nullable<int>, another +/// type, so TryFrom(int?) is another method than TryFrom(int). The return type and whether the +/// method is static are not part of it. +/// +/// +/// Between kinds, a member that is not a method takes its name from every member of the type, and from a base +/// type's for a method: Metalama introduced no method beside a property or field of its name in the type or a +/// base (LAMA0506), and C# no member beside a method of its name in the type (CS0102), while a base's method of +/// a generated property's name is hidden by it and builds (measured 2026-10-31). +/// +/// +/// Only what the value object can see counts: a base's private member is hidden from it, and the generated one +/// sits beside it (#230). +/// +/// +[CompileTime] +internal static class MemberIdentity +{ + /// + /// and are one parameter type: equal without a nullable + /// reference annotation. A nullable value type is Nullable<T>, which stays another type. + /// + public static bool SameType(IType declared, IType expected) => WithoutAnnotation(declared).Equals(WithoutAnnotation(expected)); + + private static IType WithoutAnnotation(IType type) => type.IsReferenceType == false ? type : type.ToNonNullable(); + + /// has the signature , and . + public static bool HasSignature(IMethod method, string name, int arity, IReadOnlyList parameters) => + method.Name == name + && method.TypeParameters.Count == arity + && method.Parameters.Count == parameters.Count + && method.Parameters.Zip(parameters, (declared, expected) => expected.Matches(declared, method)).All(same => same); + + /// A method without type parameters whose parameters are all by value, as every generated method is but TryParse, TryFormat and Match. + public static bool IsByValueAndNotGeneric(IMethod method) => + method.TypeParameters.Count == 0 && method.Parameters.All(parameter => parameter.RefKind == RefKind.None); + + /// + /// The members of , the value object or one of its bases, that + /// can see and that take 's place: a method of its signature, unless it is a seam, + /// which is kept, or a refusal of its own answers it; a member of its name of another kind. + /// + /// + /// An explicit implementation is never one: the interface mapping answers it (). + /// Neither is what the compiler declares implicitly, which a hand-written member cannot be. + /// + public static IEnumerable DeclaredInItsPlace(INamedType type, INamedType seenFrom, GeneratedMember generated) + { + var own = type.Equals(seenFrom); + + foreach (var member in type.Fields.Concat(type.Properties).Concat(type.Events)) + { + if (member is { IsImplicitlyDeclared: false, IsExplicitInterfaceImplementation: false } && member.Name == generated.Name && member.IsAccessibleFrom(seenFrom) && generated.ClashesByName) + yield return member; + } + + foreach (var nested in type.Types) + { + if (nested.Name == generated.Name && nested.IsAccessibleFrom(seenFrom) && generated.ClashesByName) + yield return nested; + } + + foreach (var method in type.Methods) + { + if (method is { IsImplicitlyDeclared: true } or { IsExplicitInterfaceImplementation: true } || method.Name != generated.Name || !method.IsAccessibleFrom(seenFrom)) continue; + + if (generated.Kind == GeneratedMemberKind.Method + ? generated.Role == GeneratedMemberRole.Refused && generated.HasSignatureOf(method) + : own) + yield return method; + } + } +} diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs index b1d2317..def4894 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs @@ -52,12 +52,14 @@ public override void BuildAspect(IAspectBuilder builder) HideDefaultStructConstructor(builder); + var marker = ValueObjectTypes.Markers(target)[0]; + var valueField = builder.IntroduceField( nameof(_value), IntroductionScope.Instance, OverrideStrategy.Fail, field => { field.Type = valueType; - field.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.ValueField(target, valueType).Mark(field); } ); @@ -78,9 +80,9 @@ public override void BuildAspect(IAspectBuilder builder) var entryPointArgs = new { constructor = privateConstructor.Declaration, target, kind }; - var fromJson = IntroduceEntryPoint(builder, nameof(FromJsonTemplate), "__FromJson", valueType, entryPointArgs); - var fromText = IntroduceEntryPoint(builder, nameof(FromTextTemplate), "__FromText", valueType, entryPointArgs); - var tryFromText = IntroduceEntryPoint(builder, nameof(TryFromTextTemplate), "__TryFromText", valueType, entryPointArgs); + var fromJson = IntroduceEntryPoint(builder, nameof(FromJsonTemplate), GeneratedMembers.FromJson(target, valueType, marker), valueType, entryPointArgs); + var fromText = IntroduceEntryPoint(builder, nameof(FromTextTemplate), GeneratedMembers.FromText(target, valueType, marker), valueType, entryPointArgs); + var tryFromText = IntroduceEntryPoint(builder, nameof(TryFromTextTemplate), GeneratedMembers.TryFromText(target, valueType, marker), valueType, entryPointArgs); builder.AspectState = new ValueObjectAspectState( kind, @@ -147,7 +149,7 @@ private static bool TryResolve(IAspectBuilder builder, string? wrapp return false; } - if (ValueObjectDeclaration.GeneratedMemberNames.Contains(target.Name)) + if (GeneratedMembers.NamesInAnyValueObject(target, marker).Contains(target.Name)) { builder.Diagnostics.Report(UnsupportedValueObject.WithArguments((target, $"a value object cannot be named '{target.Name}', the name of a member the generators introduce, since a member cannot have the name of its type; rename it"))); return false; @@ -423,8 +425,8 @@ private static void HideDefaultStructConstructor(IAspectBuilder buil /// private static void ImplementMaterializer(IAspectBuilder builder, INamedType valueType, IConstructor privateConstructor) { - var materializer = builder.ImplementInterface( - TypeFactory.GetNamedType(typeof(IValueObjectMaterializer<,>)).MakeGenericInstance(builder.Target, valueType)); + var contract = TypeFactory.GetNamedType(typeof(IValueObjectMaterializer<,>)).MakeGenericInstance(builder.Target, valueType); + var materializer = builder.ImplementInterface(contract); materializer.ExplicitMembers.IntroduceMethod( nameof(MaterializeTemplate), @@ -441,14 +443,13 @@ private static void ImplementMaterializer(IAspectBuilder builder, IN ); } - private static IMethod IntroduceEntryPoint(IAspectBuilder builder, string template, string name, INamedType valueType, object args) => + private static IMethod IntroduceEntryPoint(IAspectBuilder builder, string template, GeneratedMember entryPoint, INamedType valueType, object args) => builder.IntroduceMethod( template, IntroductionScope.Static, OverrideStrategy.Fail, method => { - method.Name = name; method.Accessibility = Accessibility.Private; method.Parameters[0].Type = valueType; @@ -457,9 +458,9 @@ private static IMethod IntroduceEntryPoint(IAspectBuilder builder, s else method.ReturnType = builder.Target; - method.AddAttribute(CodeAnnotations.CompilerGenerated); method.AddAttribute(CodeAnnotations.EditorNonBrowsable); method.AddAttribute(CodeAnnotations.DebuggerStepThrough); + entryPoint.Mark(method); }, args: args ).Declaration; diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectComparableAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectComparableAspect.cs index a0c3039..ea1ab6b 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectComparableAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectComparableAspect.cs @@ -78,9 +78,8 @@ public override void BuildAspect(IAspectBuilder builder) OverrideStrategy.Ignore, m => { - m.Name = nameof(IComparable.CompareTo); m.Parameters[0].Type = OperandType(builder.Target); - m.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.CompareTo(builder.Target).Mark(m); } ); @@ -92,11 +91,7 @@ public override void BuildAspect(IAspectBuilder builder) nameof(ObjectCompareTo), IntroductionScope.Instance, OverrideStrategy.Fail, - m => - { - m.Name = nameof(IComparable.CompareTo); - m.AddAttribute(CodeAnnotations.CompilerGenerated); - } + m => GeneratedMembers.ObjectCompareTo().Mark(m) ); // Comparison operators — all delegate to CompareTo @@ -114,7 +109,7 @@ public override void BuildAspect(IAspectBuilder builder) ); } - private static ValueCompareStrategy ResolveStrategy(INamedType valueType) + internal static ValueCompareStrategy ResolveStrategy(INamedType valueType) { // string.CompareTo is culture-sensitive, and the record's equality is ordinal. if (valueType.SpecialType == SpecialType.String) @@ -145,7 +140,7 @@ private static IEnumerable HandWrittenComparisonMembers(INamedType targe { if (method.IsExplicitInterfaceImplementation || !ValueObjectDeclaration.IsByValueAndNotGeneric(method)) continue; - var isObjectOverload = method is { Name: nameof(IComparable.CompareTo), Parameters: [{ Type.SpecialType: SpecialType.Object }] }; + var isObjectOverload = GeneratedMembers.ObjectCompareTo().HasSignatureOf(method); var isOrderingOperator = method.OperatorKind is OperatorKind.LessThan or OperatorKind.GreaterThan or OperatorKind.LessThanOrEqual or OperatorKind.GreaterThanOrEqual; @@ -162,9 +157,9 @@ private static IEnumerable HandWrittenComparisonMembers(INamedType targe { foreach (var method in type.Methods) { - if (method is { IsStatic: false, IsExplicitInterfaceImplementation: false, Name: nameof(IComparable.CompareTo), Parameters: [{ } other] } - && ValueObjectDeclaration.IsByValueAndNotGeneric(method) && ValueObjectDeclaration.IsHandWritten(method) && method.IsAccessibleFrom(target) - && (other.Type.SpecialType == SpecialType.Object || other.Type.ToNonNullable().Equals(target))) + if (method is { IsStatic: false, IsExplicitInterfaceImplementation: false } + && ValueObjectDeclaration.IsHandWritten(method) && method.IsAccessibleFrom(target) + && (GeneratedMembers.ObjectCompareTo().HasSignatureOf(method) || GeneratedMembers.CompareTo(target).HasSignatureOf(method))) yield return $"{method.ToDisplayString()} in its base type {type.ToDisplayString()}"; } } @@ -176,10 +171,7 @@ private static IEnumerable HandWrittenComparisonMembers(INamedType targe /// The seam: a CompareTo(TSelf) the type declares itself, which the generated one then leaves in place. private static bool DeclaresCompareTo(INamedType target) => - target.Methods.Any(method => method is { IsImplicitlyDeclared: false, IsExplicitInterfaceImplementation: false, Name: nameof(IComparable.CompareTo) } - && ValueObjectDeclaration.IsByValueAndNotGeneric(method) - && method.Parameters is [var other] - && other.Type.Equals(target)); + target.Methods.Any(method => method is { IsImplicitlyDeclared: false, IsExplicitInterfaceImplementation: false } && GeneratedMembers.CompareTo(target).HasSignatureOf(method)); /// /// The operand type: nullable for a record class, as IComparable<T>.CompareTo(T?) and diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.cs index ab795e8..b50df31 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectContractAspect.cs @@ -34,7 +34,7 @@ public override void BuildAspect(IAspectBuilder builder) { property.Accessibility = Accessibility.Public; property.Type = valueType; - property.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.Value(builder.Target, valueType).Mark(property); } ); @@ -101,7 +101,7 @@ private static void IntroduceEquality(IAspectBuilder builder, INamed if (type.Equals(direct) || !ExplicitlyImplementsEquatableBetween(direct, type, equatable.MakeGenericInstance(type))) continue; // One the value object declares itself implements the interface already, as C# maps it. - if (builder.Target.Methods.Any(method => method is { Name: nameof(Equals), Parameters: [{ } other] } && other.Type.ToNonNullable().Equals(type) && ValueObjectDeclaration.IsByValueAndNotGeneric(method))) continue; + if (builder.Target.Methods.Any(GeneratedMembers.ReimplementedEquals(type).HasSignatureOf)) continue; var hidden = type; builder.IntroduceMethod( @@ -113,7 +113,7 @@ private static void IntroduceEquality(IAspectBuilder builder, INamed method.Name = nameof(Equals); method.Accessibility = Accessibility.Public; method.Parameters[0].Type = hidden.ToNullable(); - method.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.ReimplementedEquals(hidden).Mark(method); } ); } @@ -127,7 +127,7 @@ private static void IntroduceEquality(IAspectBuilder builder, INamed method.Name = nameof(Equals); method.Accessibility = Accessibility.Public; method.Parameters[0].Type = builder.Target.ToNullable(); - method.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.RecordEquals(builder.Target).Mark(method); }, args: new { valueType } ); @@ -138,8 +138,7 @@ private static void IntroduceEquality(IAspectBuilder builder, INamed OverrideStrategy.Override, buildMethod: method => { - method.Name = nameof(GetHashCode); - method.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.RecordGetHashCode(builder.Target).Mark(method); }, args: new { valueType } ); @@ -170,7 +169,7 @@ private static void ImplementValueWrapper(IAspectBuilder builder, IT method.IsStatic = true; method.Parameters[0].Type = valueType; method.AddAttribute(CodeAnnotations.AggressiveInlining); - method.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.From(builder.Target, valueType).Mark(method); }, args: new { constructor = privateConstructor, refusesNull = valueType.IsReferenceType == true } ); @@ -192,11 +191,10 @@ private static void IntroduceTryFrom(IAspectBuilder builder, IType v OverrideStrategy.Ignore, buildMethod: method => { - method.Name = "TryFrom"; method.Accessibility = Accessibility.Public; method.ReturnType = TypeFactory.GetNamedType(typeof(Option<>)).MakeGenericInstance(builder.Target); method.Parameters[0].Type = valueType; - method.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.TryFrom(valueType, ValueObjectTypes.Markers(builder.Target)[0]).Mark(method); }, args: new { target = builder.Target } ); @@ -222,10 +220,9 @@ private static void IntroduceRevalidate(IAspectBuilder builder) OverrideStrategy.Ignore, buildMethod: method => { - method.Name = "Revalidate"; method.Accessibility = Accessibility.Public; method.ReturnType = TypeFactory.GetNamedType(typeof(Result<,>)).MakeGenericInstance(builder.Target, fault); - method.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.Revalidate(ValueObjectTypes.Markers(builder.Target)[0]).Mark(method); }, args: new { target = builder.Target } ); @@ -247,12 +244,11 @@ private static void IntroduceFromKnownGood(IAspectBuilder builder, I OverrideStrategy.Ignore, buildMethod: method => { - method.Name = "FromKnownGood"; method.Accessibility = Accessibility.Public; method.ReturnType = builder.Target; method.Parameters[0].Type = valueType; method.Parameters[1].AddAttribute(CodeAnnotations.CallerArgumentExpressionOfValue); - method.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.FromKnownGood(valueType, ValueObjectTypes.Markers(builder.Target)[0]).Mark(method); }, args: new { target = builder.Target } ); diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs index f41fc8b..207d63d 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs @@ -54,7 +54,7 @@ public static bool DeclaresToString(INamedType type) => } private static bool IsHandWrittenToString(IMethod method) => - method is { Name: nameof(ToString), IsStatic: false, IsExplicitInterfaceImplementation: false, Parameters.Count: 0 } && IsByValueAndNotGeneric(method) && IsHandWritten(method); + method is { IsStatic: false, IsExplicitInterfaceImplementation: false } && MemberIdentity.HasSignature(method, nameof(ToString), 0, []) && IsHandWritten(method); /// /// A value object and the records it derives from, left out. A struct has @@ -168,113 +168,49 @@ private static int SkipAttributeList(string text, int start) return text.Length; } - /// - /// The names of the members the generators introduce into a value object, besides Value, for - /// some marker or wrapped type: a value object of one of these names failed inside the generated - /// code (LAMA0611, CS0542: a member cannot have the name of its type), naming nothing the user wrote - /// (measured 2026-10-13 for From, TryFrom, Parse, TryParse, - /// TryFormat, MinValue and CompareTo). Refused whatever it wraps, so the rule is - /// one list rather than one per wrapped type. What a record synthesizes (ToString, - /// Equals) is C#'s own error, and an explicit implementation (IConvertible's) does not - /// collide. - /// - public static IReadOnlyList GeneratedMemberNames { get; } = - ["From", "TryFrom", "FromKnownGood", "Revalidate", "Parse", "TryParse", "TryFormat", "MinValue", "MaxValue", "CompareTo", "_value", "__FromJson", "__FromText", "__TryFromText"]; - /// /// What the declaration writes by hand that a generator introduces itself, which would fail inside - /// the generated code (LAMA0500, LAMA0503, LAMA0512, LAMA0521, LAMA0531, LAMA0611) naming nothing + /// the generated code (LAMA0500, LAMA0503, LAMA0506, LAMA0512, LAMA0521, LAMA0531, LAMA0611) naming nothing /// the user wrote, or, for a member the generators skip when it exists, would be kept silently as /// an entry point or a format the generated code never agreed to. The seams are not in it: /// TryFrom, FromKnownGood, Revalidate, CompareTo(TSelf), ToString() /// and, for a validated value object, Create. Neither are the comparison interfaces, which /// ValueObjectComparableAspect answers (CMTK1008). /// + /// + /// The members are the ones the aspects introduce (), and a hand-written + /// one takes a generated one's place by , C#'s overloading rules (decision 128). A + /// base record's count as the value object's own (#197). Beside a generated one, its public Value, + /// From, Parse, TryParse, ToString(string?, IFormatProvider?) or TryFormat failed + /// the aspect (LAMA0500), naming nothing the user wrote, and its static MinValue and MaxValue were kept + /// as the value object's, with no MinValue or MaxValue generated. One the value object cannot see, a + /// base's private member, stands in for nothing: C# hides it, and the generated one sits beside it (#230). + /// public static IReadOnlyList GeneratedMembersDeclaredByHand(INamedType target, INamedType valueType, ValueObjectKind kind) { List found = []; + var generated = GeneratedMembers.OfValueObject(target, valueType, kind); - // The interfaces the generators implement for this declaration, whose explicit implementations - // are refused below. ValueObjectContractAspect: the equality operators. - List generatedInterfaces = [TypeFactory.GetNamedType(typeof(IEqualityOperators<,,>))]; - - // A base record's count as the value object's own (#197). Beside a generated one, its public - // Value, From, Parse, TryParse, ToString(string?, IFormatProvider?) or TryFormat failed the aspect - // (LAMA0500), naming nothing the user wrote, and its static MinValue and MaxValue were kept as the - // value object's, with no MinValue or MaxValue generated. One the value object cannot see, a base's - // private member, stands in for nothing: C# hides it, and the generated one sits beside it (#230). - IEnumerable Declared(Func> find) => - SelfAndBases(target).SelectMany(type => find(type).Select(member => type.Equals(target) ? member : $"{member} in its base type {type.ToDisplayString()}")); - - // ValueObjectAspect: the field, the entry points; ValueObjectContractAspect: Value; the JSON aspect's nested converter. - found.AddRange(Declared(type => MembersNamed(type, target, "_value", "Value", "__FromJson", "__FromText", "__TryFromText", $"{target.Name}JsonConverter"))); - - if (kind == ValueObjectKind.Plain) + foreach (var member in generated) { - found.AddRange(Declared(type => MethodsWithSignature(type, target, "From", (valueType, false)))); - found.AddRange(Declared(type => MembersNamed(type, target, methods: false, "From"))); + found.AddRange(SelfAndBases(target).SelectMany(type => MemberIdentity.DeclaredInItsPlace(type, target, member) + .Select(declared => DescribeDeclared(declared) + (type.Equals(target) ? "" : $" in its base type {type.ToDisplayString()}")))); } - // A generated method's parameters, and whether each is out: an overload that takes one by value where the - // generated one takes it by reference, or the other way round, is another method (#226). - (IType, bool) stringType = (TypeFactory.GetType(SpecialType.String), false); - (IType, bool) provider = (TypeFactory.GetType(typeof(IFormatProvider)), false); - (IType, bool) result = (target, true); + // The interfaces the generators implement for this declaration, whose explicit implementations are refused + // below: those of the members refused above, and ValueObjectContractAspect's equality operators. The + // comparison interfaces are ValueObjectComparableAspect's (CMTK1008), and the contracts are checked below. + var contracts = TypeFactory.GetNamedType(typeof(IValueObject<,>)).DeclaringAssembly; - // ValueObjectParsableAspect and, where parsing is generated, ValueObjectTypeConverterAspect. - var parse = ValueObjectParsableAspect.ResolveStrategy(valueType); - - if (parse != ValueParseStrategy.Unsupported) - { - found.AddRange(Declared(type => MethodsWithSignature(type, target, "Parse", stringType, provider))); - found.AddRange(Declared(type => MethodsWithSignature(type, target, "TryParse", stringType, provider, result))); - found.AddRange(Declared(type => MembersNamed(type, target, $"{target.Name}TypeConverter"))); - generatedInterfaces.Add(TypeFactory.GetNamedType(typeof(IParsable<>))); - - if (ValueObjectParsableAspect.SupportsSpan(valueType)) - { - generatedInterfaces.Add(TypeFactory.GetNamedType(typeof(ISpanParsable<>))); - - (IType, bool) span = (TypeFactory.GetType(typeof(ReadOnlySpan)), false); - found.AddRange(Declared(type => MethodsWithSignature(type, target, "Parse", span, provider))); - found.AddRange(Declared(type => MethodsWithSignature(type, target, "TryParse", span, provider, result))); - } - - if (ValueObjectParsableAspect.SupportsUtf8(valueType)) - { - generatedInterfaces.Add(TypeFactory.GetNamedType(typeof(IUtf8SpanParsable<>))); - - (IType, bool) utf8 = (TypeFactory.GetType(typeof(ReadOnlySpan)), false); - found.AddRange(Declared(type => MethodsWithSignature(type, target, "Parse", utf8, provider))); - found.AddRange(Declared(type => MethodsWithSignature(type, target, "TryParse", utf8, provider, result))); - } - } - - // ValueObjectFormattableAspect, unless ToString() is hand-written and it generates nothing. - if (!DeclaresToString(target)) - { - found.AddRange(Declared(type => MethodsWithSignature(type, target, nameof(IFormattable.ToString), stringType, provider))); - generatedInterfaces.Add(TypeFactory.GetNamedType(typeof(IFormattable))); - - if (ValueObjectFormattableAspect.ResolveStrategy(valueType) == ValueFormatStrategy.SpanFormattable) - { - found.AddRange(Declared(type => MethodsWithSignature(type, target, nameof(ISpanFormattable.TryFormat), (TypeFactory.GetType(typeof(Span)), false), (TypeFactory.GetType(SpecialType.Int32), true), (TypeFactory.GetType(typeof(ReadOnlySpan)), false), provider))); - generatedInterfaces.Add(TypeFactory.GetNamedType(typeof(ISpanFormattable))); - } - - if (ValueObjectFormattableAspect.SupportsUtf8(valueType)) - { - found.AddRange(Declared(type => MethodsWithSignature(type, target, nameof(IUtf8SpanFormattable.TryFormat), (TypeFactory.GetType(typeof(Span)), false), (TypeFactory.GetType(SpecialType.Int32), true), (TypeFactory.GetType(typeof(ReadOnlySpan)), false), provider))); - generatedInterfaces.Add(TypeFactory.GetNamedType(typeof(IUtf8SpanFormattable))); - } - } + List generatedInterfaces = + [ + TypeFactory.GetNamedType(typeof(IEqualityOperators<,,>)), + .. generated.Where(member => member.Role == GeneratedMemberRole.Refused && !member.Contract.DeclaringAssembly.Equals(contracts)) + .Select(member => member.Contract.Definition) + .Distinct() + ]; - // ValueObjectMinMaxValueAspect. - if (kind == ValueObjectKind.Plain && ValueObjectMinMaxValueAspect.HasMinMaxValue(valueType)) - { - found.AddRange(Declared(type => MembersNamed(type, target, nameof(IMinMaxValue.MinValue), nameof(IMinMaxValue.MaxValue)))); - generatedInterfaces.Add(TypeFactory.GetNamedType(typeof(IMinMaxValue<>))); - } + var parse = ValueObjectParsableAspect.ResolveStrategy(valueType); // An explicit implementation of an interface the generators implement sat beside the generated // member, which it hides from every caller through the interface: a generic T.Parse bypassed @@ -453,14 +389,27 @@ private static string PublicName(IMember implementation, IMember implemented) /// expression parameter makes it another signature, so it is not one, and a base's private one is hidden from the /// value object, which C# never calls it for (#230). /// - public static IReadOnlyList InheritedSeams(INamedType target, INamedType valueType, ValueObjectKind kind) => - kind != ValueObjectKind.Validated - ? [] - : [.. SelfAndBases(target).Skip(1).SelectMany(type => type.Methods - .Where(method => IsHandWritten(method) && !method.IsExplicitInterfaceImplementation && IsByValueAndNotGeneric(method) && method.IsAccessibleFrom(target) - && (method is { Name: "TryFrom", IsStatic: true, Parameters: [{ } value] } && value.Type.ToNonNullable().Equals(valueType.ToNonNullable()) - || method is { Name: "Revalidate", IsStatic: false, Parameters.Count: 0 })) - .Select(method => $"{method.ToDisplayString()} in its base type {type.ToDisplayString()}"))]; + /// + /// By the generated member's signature (): a base's TryFrom(int?) over an + /// int is another method, which the generated TryFrom(int) sits beside, as it does beside the value + /// object's own (decision 128). Each seam keeps its own static-ness: an instance TryFrom is no factory. + /// + public static IReadOnlyList InheritedSeams(INamedType target, INamedType valueType, ValueObjectKind kind) + { + if (kind != ValueObjectKind.Validated) return []; + + var marker = ValueObjectTypes.Markers(target)[0]; + var tryFrom = GeneratedMembers.TryFrom(valueType, marker); + var revalidate = GeneratedMembers.Revalidate(marker); + + return + [ + .. SelfAndBases(target).Skip(1).SelectMany(type => type.Methods + .Where(method => IsHandWritten(method) && !method.IsExplicitInterfaceImplementation && method.IsAccessibleFrom(target) + && (method.IsStatic && tryFrom.HasSignatureOf(method) || !method.IsStatic && revalidate.HasSignatureOf(method))) + .Select(method => $"{method.ToDisplayString()} in its base type {type.ToDisplayString()}")) + ]; + } /// /// How a validated value object declares Create: as an explicit implementation of the @@ -531,7 +480,7 @@ public static IReadOnlyList PrintMembersDeclaredByHand(INamedType target return [ .. SelfAndBases(target).SelectMany(type => type.Methods - .Where(method => method is { Name: "PrintMembers", IsStatic: false, Parameters: [{ } builder] } && builder.Type.Equals(stringBuilder) && IsByValueAndNotGeneric(method) && IsHandWritten(method)) + .Where(method => method is { IsStatic: false } && MemberIdentity.HasSignature(method, "PrintMembers", 0, [GeneratedParameter.Of(stringBuilder)]) && IsHandWritten(method)) .Select(method => Describe(method) + (type.Equals(target) ? "" : $" in its base type {type.ToDisplayString()}"))) ]; } @@ -667,66 +616,15 @@ internal static string Describe(IMember member) internal static bool IsHandWritten(IMember member) => !member.IsImplicitlyDeclared && !member.Attributes.Any(attribute => attribute.Type.Equals(TypeFactory.GetNamedType(typeof(CompilerGeneratedAttribute)))); + /// A hand-written member that takes a generated one's place, as an error names it. + internal static string DescribeDeclared(IMemberOrNamedType declared) => + declared is IMember member ? Describe(member) : $"the nested type {declared.ToDisplayString()}"; + /// /// A method without type parameters whose parameters are all by value, as every generated method is but - /// TryParse and TryFormat (): C# overloads by arity and by a + /// TryParse and TryFormat (): C# overloads by arity and by a /// parameter's ref kind, so a generic CompareTo<T>(object?) or a TryFrom(in int) is another /// method, which the generated one sits beside, and no seam (#226). /// - internal static bool IsByValueAndNotGeneric(IMethod method) => - method.TypeParameters.Count == 0 && method.Parameters.All(parameter => parameter.RefKind == RefKind.None); - - /// - /// Non-implicit members of with one of , of any kind, that - /// can see: a base's private member is hidden from the value object (#230). - /// - private static IEnumerable MembersNamed(INamedType target, INamedType seenFrom, params string[] names) => MembersNamed(target, seenFrom, methods: true, names); - - /// Non-implicit members of with one of . - internal static IEnumerable MembersNamed(INamedType target, bool methods, params string[] names) => MembersNamed(target, target, methods, names); - - /// - /// An explicit implementation is 's, which names it, and so is a public static - /// member of another assembly that implements a static abstract one, which reads as explicit there. - /// - private static IEnumerable MembersNamed(INamedType target, INamedType seenFrom, bool methods, params string[] names) - { - foreach (var field in target.Fields) - if (!field.IsImplicitlyDeclared && Enumerable.Contains(names, field.Name) && field.IsAccessibleFrom(seenFrom)) yield return field.ToDisplayString(); - - foreach (var property in target.Properties) - if (property is { IsImplicitlyDeclared: false, IsExplicitInterfaceImplementation: false } && Enumerable.Contains(names, property.Name) && property.IsAccessibleFrom(seenFrom)) yield return property.ToDisplayString(); - - foreach (var @event in target.Events) - if (@event is { IsImplicitlyDeclared: false, IsExplicitInterfaceImplementation: false } && Enumerable.Contains(names, @event.Name) && @event.IsAccessibleFrom(seenFrom)) yield return @event.ToDisplayString(); - - foreach (var nested in target.Types) - if (Enumerable.Contains(names, nested.Name) && nested.IsAccessibleFrom(seenFrom)) yield return $"the nested type {nested.ToDisplayString()}"; - - if (!methods) yield break; - - foreach (var method in target.Methods) - if (!method.IsImplicitlyDeclared && !method.IsExplicitInterfaceImplementation && Enumerable.Contains(names, method.Name) && method.IsAccessibleFrom(seenFrom)) yield return method.ToDisplayString(); - } - - /// - /// Methods named whose parameter types are , - /// whatever they return, that can see: a generated member with that signature is - /// either refused by Metalama or skipped in favour of the hand-written one. - /// - /// - /// The signature C# overloads by (#226): no type parameters, as the generated method has none, and each - /// parameter by reference where the generated one is out, by value where it is by value. A generic - /// Parse<TFormat>(string, IFormatProvider?), a From(in int) and a TryParse whose - /// last parameter is by value are other methods, which the generated ones sit beside. ref or in - /// against out is no overload in C# (CS0663), so it is the same method, as nullability is. - /// - private static IEnumerable MethodsWithSignature(INamedType target, INamedType seenFrom, string name, params (IType Type, bool Out)[] parameters) => - target.Methods - .Where(method => method is { IsImplicitlyDeclared: false, IsExplicitInterfaceImplementation: false, TypeParameters.Count: 0 } - && method.Name == name - && method.Parameters.Count == parameters.Length - && method.Parameters.Zip(parameters, (declared, expected) => declared.Type.Equals(expected.Type) && declared.RefKind != RefKind.None == expected.Out).All(same => same) - && method.IsAccessibleFrom(seenFrom)) - .Select(method => method.ToDisplayString()); + internal static bool IsByValueAndNotGeneric(IMethod method) => MemberIdentity.IsByValueAndNotGeneric(method); } diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectFormattableAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectFormattableAspect.cs index eccc0c1..e2b8f9d 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectFormattableAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectFormattableAspect.cs @@ -61,25 +61,21 @@ public override void BuildAspect(IAspectBuilder builder) nameof(FormattableToStringTemplate), IntroductionScope.Instance, OverrideStrategy.Fail, - m => - { - m.Name = nameof(IFormattable.ToString); - m.AddAttribute(CodeAnnotations.CompilerGenerated); - } + m => GeneratedMembers.FormattableToString().Mark(m) ); // Override the parameterless ToString() so it stays consistent // with the formattable overload. Records already generate one, // so OverrideStrategy.Override is intentional here. + // + // Metalama writes this over the record's synthesized ToString(), an implicitly declared member, and applies + // none of the build delegate's attributes there, nor introduces one on it (measured 2026-10-31): the + // value object's ToString() carries neither [CompilerGenerated] nor [GeneratedMember]. builder.IntroduceMethod( nameof(ToStringOverrideTemplate), IntroductionScope.Instance, OverrideStrategy.Override, - m => - { - m.Name = nameof(IFormattable.ToString); - m.AddAttribute(CodeAnnotations.CompilerGenerated); - } + m => GeneratedMembers.ToStringOverride(builder.Target, valueType).Mark(m) ); // Mirror the IParsable → ISpanParsable layering pattern exactly. @@ -91,11 +87,7 @@ public override void BuildAspect(IAspectBuilder builder) nameof(TryFormatTemplate), IntroductionScope.Instance, OverrideStrategy.Fail, - m => - { - m.Name = nameof(ISpanFormattable.TryFormat); - m.AddAttribute(CodeAnnotations.CompilerGenerated); - } + m => GeneratedMembers.TryFormat().Mark(m) ); } @@ -107,11 +99,7 @@ public override void BuildAspect(IAspectBuilder builder) nameof(TryFormatUtf8Template), IntroductionScope.Instance, OverrideStrategy.Fail, - m => - { - m.Name = nameof(IUtf8SpanFormattable.TryFormat); - m.AddAttribute(CodeAnnotations.CompilerGenerated); - } + m => GeneratedMembers.TryFormatUtf8().Mark(m) ); } } diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectJsonAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectJsonAspect.cs index 3a2e8e2..6fb5eb7 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectJsonAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectJsonAspect.cs @@ -94,7 +94,7 @@ public override void BuildAspect(IAspectBuilder builder) type.BaseType = typeof(JsonConverter<>).ToNamedType().MakeGenericInstance(builder.Target); type.IsPartial = true; type.IsStatic = false; - type.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.JsonConverter(builder.Target, ValueObjectTypes.Markers(builder.Target)[0]).Mark(type); } ); diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectMinMaxValueAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectMinMaxValueAspect.cs index 923c5c8..1479074 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectMinMaxValueAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectMinMaxValueAspect.cs @@ -49,9 +49,8 @@ public override void BuildAspect(IAspectBuilder builder) OverrideStrategy.Ignore, p => { - p.Name = nameof(IMinMaxValue.MinValue); p.Type = builder.Target; - p.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.MinValue(builder.Target).Mark(p); } ); @@ -61,9 +60,8 @@ public override void BuildAspect(IAspectBuilder builder) OverrideStrategy.Ignore, p => { - p.Name = nameof(IMinMaxValue.MaxValue); p.Type = builder.Target; - p.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.MaxValue(builder.Target).Mark(p); } ); } diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs index 54a65ed..7d1cd53 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectParsableAspect.cs @@ -156,50 +156,48 @@ public override void BuildAspect(IAspectBuilder builder) }; builder.ImplementInterface(typeof(IParsable<>).ToNamedType().MakeGenericInstance(builder.Target), OverrideStrategy.Ignore); - IntroduceParse(builder, nameof(ParseTemplate), nameof(IParsable<>.Parse)); - IntroduceTryParse(builder, nameof(TryParseTemplate), nameof(IParsable<>.TryParse)); + IntroduceParse(builder, nameof(ParseTemplate), TypeFactory.GetType(SpecialType.String)); + IntroduceTryParse(builder, nameof(TryParseTemplate), TypeFactory.GetType(SpecialType.String)); // By the wrapped type, not the strategy: the string strategy, picked first, dropped string's own // ISpanParsable (found by the prober, claim C11, 2026-10-17). if (supportsSpan) { builder.ImplementInterface(typeof(ISpanParsable<>).ToNamedType().MakeGenericInstance(builder.Target), OverrideStrategy.Ignore); - IntroduceParse(builder, nameof(SpanParseTemplate), nameof(ISpanParsable<>.Parse)); - IntroduceTryParse(builder, nameof(SpanTryParseTemplate), nameof(ISpanParsable<>.TryParse)); + IntroduceParse(builder, nameof(SpanParseTemplate), TypeFactory.GetType(typeof(ReadOnlySpan))); + IntroduceTryParse(builder, nameof(SpanTryParseTemplate), TypeFactory.GetType(typeof(ReadOnlySpan))); } if (supportsUtf8) { builder.ImplementInterface(typeof(IUtf8SpanParsable<>).ToNamedType().MakeGenericInstance(builder.Target), OverrideStrategy.Ignore); - IntroduceParse(builder, nameof(Utf8SpanParseTemplate), nameof(IUtf8SpanParsable<>.Parse)); - IntroduceTryParse(builder, nameof(Utf8SpanTryParseTemplate), nameof(IUtf8SpanParsable<>.TryParse)); + IntroduceParse(builder, nameof(Utf8SpanParseTemplate), TypeFactory.GetType(typeof(ReadOnlySpan))); + IntroduceTryParse(builder, nameof(Utf8SpanTryParseTemplate), TypeFactory.GetType(typeof(ReadOnlySpan))); } } // A hand-written Parse or TryParse with these signatures is CMTK1011, so Fail is a backstop, never a // silent keep of an entry point that need not apply Create. - private static void IntroduceParse(IAspectBuilder builder, string template, string name) => + private static void IntroduceParse(IAspectBuilder builder, string template, IType text) => builder.IntroduceMethod( template, IntroductionScope.Static, OverrideStrategy.Fail, method => { - method.Name = name; method.ReturnType = builder.Target; - method.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.Parse(builder.Target, text).Mark(method); }); - private static void IntroduceTryParse(IAspectBuilder builder, string template, string name) => + private static void IntroduceTryParse(IAspectBuilder builder, string template, IType text) => builder.IntroduceMethod( template, IntroductionScope.Static, OverrideStrategy.Fail, method => { - method.Name = name; method.Parameters["result"].Type = builder.Target; - method.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.TryParse(builder.Target, text).Mark(method); }); /// Whether ISpanParsable is generated: the wrapped type implements it, whatever its strategy for text. diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.cs index ab5020e..1bfb6c2 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectTypeConverterAspect.cs @@ -30,7 +30,7 @@ public override void BuildAspect(IAspectBuilder builder) t.BaseType = TypeFactory.GetNamedType(typeof(TypeConverter)); t.IsPartial = true; t.IsStatic = false; - t.AddAttribute(CodeAnnotations.CompilerGenerated); + GeneratedMembers.TypeConverter(builder.Target, ValueObjectTypes.Markers(builder.Target)[0]).Mark(t); } ); diff --git a/test/CodoMetis.TypeKit.Generators.Tests/BuildOutcomeTests.cs b/test/CodoMetis.TypeKit.Generators.Tests/BuildOutcomeTests.cs index da9acf4..31043e3 100644 --- a/test/CodoMetis.TypeKit.Generators.Tests/BuildOutcomeTests.cs +++ b/test/CodoMetis.TypeKit.Generators.Tests/BuildOutcomeTests.cs @@ -196,6 +196,8 @@ public void A_member_name_the_generators_take_is_refused_with_the_reason(string [InlineData("SetOverLibraryOpenToString", "LibraryOpenToStringSetBase.ToString() in its base type, which is not sealed")] [InlineData("SetWithTypeConverterAttribute", "the attribute TypeConverter")] [InlineData("SetWithJsonConverterAttribute", "the attribute JsonConverter")] + [InlineData("SetWithNameMethod", "SetWithNameMethod.Name()")] + [InlineData("SetOverNestedConverterBase", "the nested type NestedConverterSetBase.SetOverNestedConverterBaseJsonConverter in its base type NestedConverterSetBase")] public void What_the_generators_implement_or_attach_is_refused_by_name_on_a_set(string type, string declared) => consumer.Errors.ShouldContain(error => error.Id == "CMTK1011" && error.Message.StartsWith($"'{type}' declares ") && error.Message.Contains(declared), consumer.Output); @@ -213,6 +215,25 @@ public void What_the_generators_implement_or_attach_is_refused_by_name_on_a_set( public void What_a_set_s_base_class_declares_out_of_the_generators_way_is_not_refused(string type) => consumer.Errors.ShouldNotContain(error => error.Message.Contains($"'{type}"), consumer.Output); + /// + /// A member that C# overloads or hides beside the generated one is no hand-written generated member (decision 128): + /// int? is Nullable<int>, another type than int, so a base's TryFrom(int?) and a set's + /// Parse(string, bool?) are other methods, as the value object's own TryFrom(int?) already was; a base's + /// method of a generated property's or field's name is hidden by it; an entry point's overload of another signature + /// is another method. Each was CMTK1011 through a check of its own, and each builds with warnings as errors and + /// answers through the generated member (measured 2026-10-31). A set base's All() built before and still does. + /// + [Theory] + [InlineData("OverNullableTryFromBase")] + [InlineData("SetWithNullableIgnoreCaseParse")] + [InlineData("OverMinValueMethodBase")] + [InlineData("OverValueMethodBase")] + [InlineData("OverFieldMethodBase")] + [InlineData("EntryPointOverloaded")] + [InlineData("SetOverAllMethodBase")] + public void A_member_C_s_rules_keep_apart_from_the_generated_one_builds(string type) => + consumer.Errors.ShouldNotContain(error => error.Message.Contains($"'{type}"), consumer.Output); + /// /// A member whose name starts with the Kelvin sign (U+212A) and one that starts with K are two names /// to TryParse(name, ignoreCase: true), which ignores case ordinally, and one to Match, @@ -343,6 +364,11 @@ public void A_part_a_source_generator_adds_does_not_count() => [InlineData("TryParseByRef", "TryParseByRef.TryParse(string?, IFormatProvider?, ref TryParseByRef)")] [InlineData("TryParseByIn", "TryParseByIn.TryParse(string?, IFormatProvider?, in TryParseByIn)")] [InlineData("ParseOfOtherNullability", "ParseOfOtherNullability.Parse(string?, IFormatProvider)")] + [InlineData("ParseAsProperty", "ParseAsProperty.Parse")] + [InlineData("OverParsePropertyBase", "ParsePropertyBase.Parse in its base type ParsePropertyBase")] + [InlineData("OverTryFormatFieldBase", "TryFormatFieldBase.TryFormat in its base type TryFormatFieldBase")] + [InlineData("TryFromAsProperty", "TryFromAsProperty.TryFrom")] + [InlineData("CompareToAsField", "CompareToAsField.CompareTo")] [InlineData("TryFormatByRef", "TryFormatByRef.TryFormat(Span, ref int, ReadOnlySpan, IFormatProvider?)")] [InlineData("HandWrittenMinValue", "HandWrittenMinValue.MinValue")] [InlineData("HandWrittenJsonConverter", "the attribute JsonConverter")] @@ -1997,6 +2023,60 @@ public Chained() : this(Fine.From(1)) { } public Fine Id { get; } } + + // Another kind of member of a generated member's name: Metalama introduced no method beside it (LAMA0506), + // in the type or a base, now CMTK1011 (decision 128). + public readonly partial record struct ParseAsProperty : IValue { public static int Parse => 1; } + + public abstract record ParsePropertyBase { public static int Parse => 1; } + + public sealed partial record OverParsePropertyBase : ParsePropertyBase, IValue; + + public abstract record TryFormatFieldBase { public static int TryFormat = 1; } + + public sealed partial record OverTryFormatFieldBase : TryFormatFieldBase, IValue; + + public readonly partial record struct TryFromAsProperty : IValidatedValue + { + public static Result Create(int value) => Result.Error(Fault.Refused); + + public static int TryFrom => 1; + } + + public readonly partial record struct CompareToAsField : IValue { public static int CompareTo = 1; } + + // What C#'s overloading and hiding keep apart from a generated member, which builds beside it (decision 128). + public abstract record NullableTryFromBase { public static Option TryFrom(int? value) => Option.None(); } + + public sealed partial record OverNullableTryFromBase : NullableTryFromBase, IValidatedValue + { + public static Result Create(int value) => Result.Error(Fault.Refused); + } + + public sealed partial class SetWithNullableIgnoreCaseParse : IClosedSet + { + public static readonly SetWithNullableIgnoreCaseParse A = new(); + + public static SetWithNullableIgnoreCaseParse Parse(string name, bool? ignoreCase) => A; + } + + public abstract record MinValueMethodBase { public static int MinValue() => 1; } + + public sealed partial record OverMinValueMethodBase : MinValueMethodBase, IValue; + + public abstract record ValueMethodBase { public int Value() => 1; } + + public sealed partial record OverValueMethodBase : ValueMethodBase, IValue; + + public abstract record FieldMethodBase { public int _value() => 1; } + + public sealed partial record OverFieldMethodBase : FieldMethodBase, IValue; + + public readonly partial record struct EntryPointOverloaded : IValue { private static int __FromJson(string value) => 1; } + + public abstract class AllMethodSetBase { public static int All() => 1; } + + public sealed partial class SetOverAllMethodBase : AllMethodSetBase, IClosedSet { public static readonly SetOverAllMethodBase A = new(); } """; /// @@ -2135,6 +2215,14 @@ public interface ISetParsesItself : System.IParsable where TSelf : public sealed partial class SetWithIgnoreCaseParse : IClosedSet { public static readonly SetWithIgnoreCaseParse A = new(); public static SetWithIgnoreCaseParse Parse(string name, bool ignoreCase) => A; } + // A method of a generated property's name: CS0102 inside the generated code (LAMA0611), now CMTK1011. + public sealed partial class SetWithNameMethod : IClosedSet { public static readonly SetWithNameMethod A = new(); public string Name() => ""; } + + // A base's nested type of a generated one's name: LAMA0531, now CMTK1011. + public abstract class NestedConverterSetBase { public sealed class SetOverNestedConverterBaseJsonConverter; } + + public sealed partial class SetOverNestedConverterBase : NestedConverterSetBase, IClosedSet { public static readonly SetOverNestedConverterBase A = new(); } + // Named as a generated member: LAMA0611 (CS0542) inside the generated code. public static class SetNames { diff --git a/tools/BuildVerdict/build-verdict-remedies.tsv b/tools/BuildVerdict/build-verdict-remedies.tsv index d702743..a7f3968 100644 --- a/tools/BuildVerdict/build-verdict-remedies.tsv +++ b/tools/BuildVerdict/build-verdict-remedies.tsv @@ -13,7 +13,7 @@ CMTK0010 A type argument breaks its parameter's [Abstract], [Record], [Sealed] o CMTK0011 A type the host constructs by reflection lacks the required parameterless constructor Add one with the accessibility the attribute asks for; the code fix writes it, except for a type with a primary constructor (docs/type-constraints.md). CMTK0012 A closed set's Match called with positional arguments Name every argument: Match binds by declaration order, so reordering two members swaps their branches silently. CMTK0013 A closed set's member assigned in its static constructor or another initializer Initialize each member with new where it is declared, and nowhere else. -CMTK1011 A hand-written member the generators introduce Remove it. Only TryFrom, FromKnownGood, Revalidate, CompareTo(TSelf) and ToString() may be written by hand (the seams); everything else is generated. A new generated member must join this check, or a hand-written one is kept silently. +CMTK1011 A hand-written member the generators introduce Remove it. Only TryFrom, FromKnownGood, Revalidate, CompareTo(TSelf) and ToString() may be written by hand (the seams); everything else is generated. A property, field or nested type of a generated member's name counts too. A new generated member is introduced through its GeneratedMembers entry, which this check reads (decision 128). CMTK1* A declaration the generators refuse, so the type is not generated The message names the fix; the Generators README's "Build errors" table explains each id. Fix it before any CS or LAMA error on the same type -- those are usually its cascade. LAMA0611 A compiler error inside aspect-generated code Usually a cascade: fix the CMTK error in the same verdict and rebuild. With no CMTK error, the declaration reached a case the generators do not refuse yet -- that is a missing CMTK rule, not a fix in woven code (design/aspects.md, "Build failures that named nothing the user wrote"). Read the woven code as the Generators README's "Reading the generated code" says. LAMA0612 Metalama's generic note that an aspect probably has a bug Follows LAMA0611; act on the LAMA0611 or CMTK error in the same verdict. From 347b860ed1c99a3ac1dc9230e733908bda257c57 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ricardo=20Gro=C3=9F?= Date: Sat, 31 Oct 2026 21:12:05 +0100 Subject: [PATCH 3/3] feat: mark every generated member with [GeneratedMember], naming the contract member it implements GeneratedMemberAttribute(Type contract, string member), in the Metalama-free base package's CompilerServices: the interface the member implements (IParsable.Parse), or the marker that promises it (IValidatedValue.TryFrom). Not [GeneratedCode], which analyzers skip. Every GeneratedMembers entry adds it beside [CompilerGenerated]; explicit implementations, operators, constructors and the companion's methods get it where they are introduced. ValueObjectDeclaration.IsHandWritten reads it, and a hand-written one on a value object's or a closed set's member is CMTK1011. Metalama 2026.1 writes the override of a record's implicit ToString(), and of Equals and GetHashCode() over a base record, over that declaration and applies no attribute to it, nor introduces one there (measured), so those carry neither attribute, as they carried no [CompilerGenerated] before. GeneratedSurface.verified.txt names each member's contract member and is otherwise unchanged; GeneratedMemberAttributeTests holds that every member with [CompilerGenerated] carries the mark and none without it does, in this assembly and the probes'. Seeded: no mark on catalogue members (182 rows fail), a hand-written mark not refused (its row fails). A surface waiver covers the attribute, which no document promises yet. Refs #239 Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 1 + .../ClosedSetAspect.cs | 3 + .../ClosedSetTypes.cs | 1 + .../CodeAnnotations.cs | 9 + .../GeneratedMember.cs | 6 +- .../GeneratedMembers.cs | 4 +- .../ValueObjectArithmeticAspect.cs | 1 + .../ValueObjectAspect.cs | 2 + .../ValueObjectCompanionAspect.cs | 3 + .../ValueObjectComparableAspect.cs | 1 + .../ValueObjectConvertibleAspect.cs | 4 + .../ValueObjectDeclaration.cs | 21 +- .../GeneratedMemberAttribute.cs | 46 + .../BuildOutcomeTests.cs | 8 + .../GeneratedMemberAttributeTests.cs | 85 + .../GeneratedSurface.verified.txt | 6764 ++++++++--------- .../GeneratedSurfaceTests.cs | 18 +- test/oracles/surface-waivers.json | 1 + 18 files changed, 3584 insertions(+), 3394 deletions(-) create mode 100644 src/CodoMetis.TypeKit/CompilerServices/GeneratedMemberAttribute.cs create mode 100644 test/CodoMetis.TypeKit.Generators.Tests/GeneratedMemberAttributeTests.cs diff --git a/CHANGELOG.md b/CHANGELOG.md index 70c80d1..52adf23 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,7 @@ section is the GitHub release's notes. - Generators: a plain value object that declares `IAdditionOperators`, `ISubtractionOperators`, `IMultiplyOperators`, `IDivisionOperators`, `IModulusOperators`, `IUnaryNegationOperators` or `IUnaryPlusOperators` gets their operators, `Money + Money` or `Money * 3m`, each the underlying type's own, overflow and `checked` context included; nothing without the interface, nothing on a validated value object, and an operator you wrote is kept ([Add, subtract and scale](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/docs/value-objects.md#add-subtract-and-scale)). - EF Core: those operators run in a query as the underlying type's arithmetic on SQLite, PostgreSQL and SQL Server, `o.Price * 2m > limit` and `o.Tax / o.Price` included ([Queries](https://github.com/CaffeinatedCoder/CodoMetis.TypeKit/blob/main/src/CodoMetis.TypeKit.EntityFrameworkCore/README.md#queries)). +- Generators: every member the generators add carries `[GeneratedMember]` from `CodoMetis.TypeKit.CompilerServices`, naming the interface member it implements, such as `IParsable.Parse`, so code that reads members can tell generated from hand-written without a list of names. A value object's `ToString()` doesn't carry it: Metalama can't put an attribute there. ### Changed diff --git a/src/CodoMetis.TypeKit.Generators/ClosedSetAspect.cs b/src/CodoMetis.TypeKit.Generators/ClosedSetAspect.cs index aae860a..a41a19c 100644 --- a/src/CodoMetis.TypeKit.Generators/ClosedSetAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ClosedSetAspect.cs @@ -111,6 +111,7 @@ public override void BuildAspect(IAspectBuilder builder) { c.Accessibility = Accessibility.Private; c.AddAttribute(CodeAnnotations.CompilerGenerated); + c.AddAttribute(CodeAnnotations.GeneratedMember(TypeFactory.GetNamedType(typeof(IClosedSet<>)).WithTypeArguments(target), nameof(IClosedSet<>.All))); }); } @@ -186,12 +187,14 @@ public override void BuildAspect(IAspectBuilder builder) m.Name = "Parse"; m.ReturnType = target; m.AddAttribute(CodeAnnotations.CompilerGenerated); + m.AddAttribute(CodeAnnotations.GeneratedMember(TypeFactory.GetNamedType(typeof(IParsable<>)).WithTypeArguments(target), nameof(IParsable<>.Parse))); }); parsable.ExplicitMembers.IntroduceMethod(nameof(ParsableTryParseTemplate), IntroductionScope.Static, OverrideStrategy.Fail, m => { m.Name = "TryParse"; m.Parameters[2].Type = target; m.AddAttribute(CodeAnnotations.CompilerGenerated); + m.AddAttribute(CodeAnnotations.GeneratedMember(TypeFactory.GetNamedType(typeof(IParsable<>)).WithTypeArguments(target), nameof(IParsable<>.TryParse))); }); builder.IntroduceMethod(nameof(MatchTemplate), IntroductionScope.Instance, OverrideStrategy.Fail, m => diff --git a/src/CodoMetis.TypeKit.Generators/ClosedSetTypes.cs b/src/CodoMetis.TypeKit.Generators/ClosedSetTypes.cs index 27d7af0..fa73aa4 100644 --- a/src/CodoMetis.TypeKit.Generators/ClosedSetTypes.cs +++ b/src/CodoMetis.TypeKit.Generators/ClosedSetTypes.cs @@ -218,6 +218,7 @@ .. GeneratedMembers.OfClosedSet(set, members.Count) .SelectMany(type => MemberIdentity.DeclaredInItsPlace(type, set, generated) .Where(declared => !(declared is IField field && members.Contains(field))) .Select(declared => ValueObjectDeclaration.DescribeDeclared(declared) + (type.Equals(set) ? "" : $" in its base type {type.ToDisplayString()}")))), + .. ValueObjectDeclaration.GeneratedMemberAttributesWrittenByHand(set), .. ValueObjectDeclaration.ImplementationsOf(set, [TypeFactory.GetNamedType(typeof(IClosedSet<>))]), .. set.ImplementedInterfaces.Where(implemented => implemented.Equals(parsable)).Select(implemented => $"the interface {implemented.ToDisplayString()}"), .. set.ImplementedInterfaces.Where(implemented => implemented.AllImplementedInterfaces.Any(inherited => inherited.Equals(parsable))).Select(implemented => $"the interface {parsable.ToDisplayString()} in its interface {implemented.ToDisplayString()}"), diff --git a/src/CodoMetis.TypeKit.Generators/CodeAnnotations.cs b/src/CodoMetis.TypeKit.Generators/CodeAnnotations.cs index fa34171..b4300be 100644 --- a/src/CodoMetis.TypeKit.Generators/CodeAnnotations.cs +++ b/src/CodoMetis.TypeKit.Generators/CodeAnnotations.cs @@ -3,6 +3,7 @@ using System.Runtime.CompilerServices; using CodoMetis.TypeKit.CompilerServices; using Metalama.Framework.Aspects; +using Metalama.Framework.Code; using Metalama.Framework.Code.DeclarationBuilders; namespace CodoMetis.TypeKit.Generators; @@ -38,6 +39,14 @@ internal static class CodeAnnotations public static AttributeConstruction EditorNonBrowsable => AttributeConstruction.Create(typeof(EditorBrowsableAttribute), [EditorBrowsableState.Never]); + /// + /// [GeneratedMember(typeof(contract), member)], on every member the generators introduce. A named member + /// gets it from its entry; what no check finds by name (an explicit + /// implementation, an operator, a constructor, a companion's method) gets it here, where it is introduced. + /// + public static AttributeConstruction GeneratedMember(IType contract, string member) => + AttributeConstruction.Create(typeof(GeneratedMemberAttribute), [contract, member]); + public static AttributeConstruction TranslatedAsWrappedValue => AttributeConstruction.Create(typeof(TranslatedAsWrappedValueAttribute)); diff --git a/src/CodoMetis.TypeKit.Generators/GeneratedMember.cs b/src/CodoMetis.TypeKit.Generators/GeneratedMember.cs index fb130a3..b9eec8e 100644 --- a/src/CodoMetis.TypeKit.Generators/GeneratedMember.cs +++ b/src/CodoMetis.TypeKit.Generators/GeneratedMember.cs @@ -1,3 +1,4 @@ +using CodoMetis.TypeKit.CompilerServices; using Metalama.Framework.Aspects; using Metalama.Framework.Code; using Metalama.Framework.Code.DeclarationBuilders; @@ -60,8 +61,8 @@ public bool Matches(IParameter parameter, IMethod method) => /// /// One member the generators introduce: its name, kind and signature, which both its introduction and the check -/// of a hand-written member beside it read, and the contract it implements (decision 128). Made by -/// . +/// of a hand-written member beside it read, and the contract it implements, which +/// names on it (decision 128). Made by . /// [CompileTime] internal sealed class GeneratedMember @@ -149,5 +150,6 @@ public void Mark(INamedTypeBuilder type) private void AddAttributes(IDeclarationBuilder declaration) { declaration.AddAttribute(CodeAnnotations.CompilerGenerated); + declaration.AddAttribute(CodeAnnotations.GeneratedMember(Contract, ContractMember)); } } diff --git a/src/CodoMetis.TypeKit.Generators/GeneratedMembers.cs b/src/CodoMetis.TypeKit.Generators/GeneratedMembers.cs index 316206f..d8ff502 100644 --- a/src/CodoMetis.TypeKit.Generators/GeneratedMembers.cs +++ b/src/CodoMetis.TypeKit.Generators/GeneratedMembers.cs @@ -18,8 +18,8 @@ namespace CodoMetis.TypeKit.Generators; /// /// Not here: what no check finds by its name. An explicit implementation (the materializer, IConvertible, /// a closed set's IParsable<TSelf>) is found by the interface mapping, an operator by its kind, a -/// constructor by CMTK1009, and the companion class by CMTK1007, each by -/// its own check. Neither are the members a record +/// constructor by CMTK1009, and the companion class by CMTK1007; each is marked by +/// where it is introduced. Neither are the members a record /// synthesizes and the generators replace (Equals, GetHashCode), which the equality checks answer. /// /// diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectArithmeticAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectArithmeticAspect.cs index 6e0c854..cf0afb9 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectArithmeticAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectArithmeticAspect.cs @@ -159,6 +159,7 @@ void Introduce(OperatorKind kind, string helperName) method.ReturnType = result; method.OperatorKind = kind; method.AddAttribute(CodeAnnotations.CompilerGenerated); + method.AddAttribute(CodeAnnotations.GeneratedMember(declared, method.Name)); // What tells an EF Core query this operator from one written by hand, which it refuses. method.AddAttribute(CodeAnnotations.TranslatedAsWrappedArithmetic); diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs index def4894..f798e59 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectAspect.cs @@ -71,6 +71,7 @@ public override void BuildAspect(IAspectBuilder builder) constructor.InitializerKind = ConstructorInitializerKind.None; constructor.Parameters[0].Type = valueType; constructor.AddAttribute(CodeAnnotations.CompilerGenerated); + constructor.AddAttribute(CodeAnnotations.GeneratedMember(GeneratedMembers.Construction(target, valueType, marker), GeneratedMembers.ConstructionMember(marker))); constructor.AddAttribute(CodeAnnotations.DebuggerStepThrough); }, args: new { valueField = valueField.Declaration } @@ -438,6 +439,7 @@ private static void ImplementMaterializer(IAspectBuilder builder, IN method.ReturnType = builder.Target; method.Parameters[0].Type = valueType; method.AddAttribute(CodeAnnotations.CompilerGenerated); + method.AddAttribute(CodeAnnotations.GeneratedMember(contract, nameof(IValueObjectMaterializer<,>.Materialize))); }, args: new { constructor = privateConstructor } ); diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectCompanionAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectCompanionAspect.cs index f5efadf..162525e 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectCompanionAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectCompanionAspect.cs @@ -1,3 +1,4 @@ +using CodoMetis.TypeKit.ValueObjects; using Metalama.Framework.Aspects; using Metalama.Framework.Code; @@ -78,6 +79,7 @@ public override void BuildAspect(IAspectBuilder builder) method.Parameters[0].Type = builder.Target.ToNonNullable(); method.Parameters[0].IsThis = true; method.AddAttribute(CodeAnnotations.CompilerGenerated); + method.AddAttribute(CodeAnnotations.GeneratedMember(TypeFactory.GetNamedType(typeof(IValueObject<,>)).MakeGenericInstance(builder.Target, valueType), nameof(IValueObject<,>.Value))); method.AddAttribute(CodeAnnotations.TranslatedAsWrappedValue); } ); @@ -95,6 +97,7 @@ public override void BuildAspect(IAspectBuilder builder) method.Parameters[0].Type = builder.Target.ToNullable(); method.Parameters[0].IsThis = true; method.AddAttribute(CodeAnnotations.CompilerGenerated); + method.AddAttribute(CodeAnnotations.GeneratedMember(TypeFactory.GetNamedType(typeof(IValueObject<,>)).MakeGenericInstance(builder.Target, valueType), nameof(IValueObject<,>.Value))); method.AddAttribute(CodeAnnotations.TranslatedAsWrappedValue); } ); diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectComparableAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectComparableAspect.cs index ea1ab6b..b7d7a8b 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectComparableAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectComparableAspect.cs @@ -194,6 +194,7 @@ OperatorKind operatorKind m.OperatorKind = operatorKind; m.AddAttribute(CodeAnnotations.AggressiveInlining); m.AddAttribute(CodeAnnotations.CompilerGenerated); + m.AddAttribute(CodeAnnotations.GeneratedMember(TypeFactory.GetNamedType(typeof(IComparisonOperators<,,>)).MakeGenericInstance(builder.Target, builder.Target, TypeFactory.GetNamedType(typeof(bool))), m.Name)); }); } } diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectConvertibleAspect.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectConvertibleAspect.cs index 7874edd..170948d 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectConvertibleAspect.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectConvertibleAspect.cs @@ -54,6 +54,7 @@ public override void BuildAspect(IAspectBuilder builder) { m.Name = nameof(IConvertible.GetTypeCode); m.AddAttribute(CodeAnnotations.CompilerGenerated); + m.AddAttribute(CodeAnnotations.GeneratedMember(TypeFactory.GetNamedType(typeof(IConvertible)), nameof(IConvertible.GetTypeCode))); }, args: new { referenceType } ); @@ -67,6 +68,7 @@ public override void BuildAspect(IAspectBuilder builder) { m.Name = nameof(IConvertible.ToType); m.AddAttribute(CodeAnnotations.CompilerGenerated); + m.AddAttribute(CodeAnnotations.GeneratedMember(TypeFactory.GetNamedType(typeof(IConvertible)), nameof(IConvertible.ToType))); }, args: new { valueObjectType = builder.Target, declaresToString = state.DeclaresToString, referenceType } ); @@ -82,6 +84,7 @@ public override void BuildAspect(IAspectBuilder builder) { m.Name = nameof(IConvertible.ToString); m.AddAttribute(CodeAnnotations.CompilerGenerated); + m.AddAttribute(CodeAnnotations.GeneratedMember(TypeFactory.GetNamedType(typeof(IConvertible)), nameof(IConvertible.ToString))); }, args: new { declaresToString = state.DeclaresToString, referenceType } ); @@ -101,6 +104,7 @@ public override void BuildAspect(IAspectBuilder builder) m.Name = capturedMethodName; m.ReturnType = capturedReturnType.ToNamedType(); m.AddAttribute(CodeAnnotations.CompilerGenerated); + m.AddAttribute(CodeAnnotations.GeneratedMember(TypeFactory.GetNamedType(typeof(IConvertible)), capturedMethodName)); }, args: new { diff --git a/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs b/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs index 207d63d..8241c4d 100644 --- a/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs +++ b/src/CodoMetis.TypeKit.Generators/ValueObjectDeclaration.cs @@ -210,6 +210,9 @@ .. generated.Where(member => member.Role == GeneratedMemberRole.Refused && !memb .Distinct() ]; + // A hand-written [GeneratedMember] would make a member read as generated to whatever reads the attribute. + found.AddRange(GeneratedMemberAttributesWrittenByHand(target)); + var parse = ValueObjectParsableAspect.ResolveStrategy(valueType); // An explicit implementation of an interface the generators implement sat beside the generated @@ -610,11 +613,23 @@ internal static string Describe(IMember member) } /// - /// Written by the user, not synthesized by the compiler: a record in a referenced assembly reports its - /// synthesized members as declared, and marks them [CompilerGenerated]. + /// Written by the user, not synthesized by the compiler nor introduced by the generators: a record in a referenced + /// assembly reports its synthesized members as declared, and marks them [CompilerGenerated], and every + /// member the generators introduce carries (decision 128). /// internal static bool IsHandWritten(IMember member) => - !member.IsImplicitlyDeclared && !member.Attributes.Any(attribute => attribute.Type.Equals(TypeFactory.GetNamedType(typeof(CompilerGeneratedAttribute)))); + !member.IsImplicitlyDeclared + && !member.Attributes.Any(attribute => attribute.Type.Equals(TypeFactory.GetNamedType(typeof(CompilerGeneratedAttribute))) || attribute.Type.Equals(TypeFactory.GetNamedType(typeof(GeneratedMemberAttribute)))); + + /// + /// The members of that carry a before anything is + /// introduced, which can only have been written by hand: it would make the member read as generated to whatever + /// reads the attribute, as the generators' own attributes on the type would (CMTK1011). + /// + internal static IEnumerable GeneratedMemberAttributesWrittenByHand(INamedType target) => + target.Fields.Concat(target.Properties).Concat(target.Events).Concat(target.Methods).Concat(target.Constructors).Concat(target.Types) + .Where(member => member.Attributes.Any(attribute => attribute.Type.Equals(TypeFactory.GetNamedType(typeof(GeneratedMemberAttribute))))) + .Select(member => $"the attribute GeneratedMember on {(member is IMember declared ? Describe(declared) : member.ToDisplayString())}"); /// A hand-written member that takes a generated one's place, as an error names it. internal static string DescribeDeclared(IMemberOrNamedType declared) => diff --git a/src/CodoMetis.TypeKit/CompilerServices/GeneratedMemberAttribute.cs b/src/CodoMetis.TypeKit/CompilerServices/GeneratedMemberAttribute.cs new file mode 100644 index 0000000..4e5d8dc --- /dev/null +++ b/src/CodoMetis.TypeKit/CompilerServices/GeneratedMemberAttribute.cs @@ -0,0 +1,46 @@ +using System.ComponentModel; + +namespace CodoMetis.TypeKit.CompilerServices; + +/// +/// Put by CodoMetis.TypeKit.Generators on every member it introduces into a value object, a closed set +/// or a value object's companion class: the contract the member implements, and which of its members. +/// +/// +/// +/// is the interface the member implements (IParsable<OrderId> for the +/// generated Parse(string, IFormatProvider?)), or, for a member no interface declares, the marker +/// that promises it (IValidatedValue<Sku, string, SkuFault> for TryFrom). +/// is that member's name in the contract, or the generated member's own where the +/// contract declares none. +/// +/// +/// Code that has a member in hand reads it to tell a generated member from one written by hand, without +/// a list of names, as tells a value object from any other +/// type. Not [GeneratedCode]: Roslyn analyzers skip code marked with it by default, which would +/// silence the CMTK rules and the application's own analyzers on these members. +/// +/// +/// Nothing to write by hand: a hand-written one on a value object's or a closed set's member is CMTK1011, +/// as for every attribute the generators put there. +/// +/// +[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Constructor | AttributeTargets.Event | AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)] +[EditorBrowsable(EditorBrowsableState.Never)] +public sealed class GeneratedMemberAttribute : Attribute +{ + /// Marks a generated member as implementing of . + /// The interface the member implements, or the marker that promises it. + /// The name of the contract's member, or the generated member's own. + public GeneratedMemberAttribute(Type contract, string member) + { + Contract = contract; + Member = member; + } + + /// The interface the member implements, or the marker that promises it. + public Type Contract { get; } + + /// The name of the contract's member the generated member implements, or its own where the contract declares none. + public string Member { get; } +} diff --git a/test/CodoMetis.TypeKit.Generators.Tests/BuildOutcomeTests.cs b/test/CodoMetis.TypeKit.Generators.Tests/BuildOutcomeTests.cs index 31043e3..5b17261 100644 --- a/test/CodoMetis.TypeKit.Generators.Tests/BuildOutcomeTests.cs +++ b/test/CodoMetis.TypeKit.Generators.Tests/BuildOutcomeTests.cs @@ -369,6 +369,7 @@ public void A_part_a_source_generator_adds_does_not_count() => [InlineData("OverTryFormatFieldBase", "TryFormatFieldBase.TryFormat in its base type TryFormatFieldBase")] [InlineData("TryFromAsProperty", "TryFromAsProperty.TryFrom")] [InlineData("CompareToAsField", "CompareToAsField.CompareTo")] + [InlineData("MarkedByHand", "the attribute GeneratedMember on MarkedByHand.Hidden()")] [InlineData("TryFormatByRef", "TryFormatByRef.TryFormat(Span, ref int, ReadOnlySpan, IFormatProvider?)")] [InlineData("HandWrittenMinValue", "HandWrittenMinValue.MinValue")] [InlineData("HandWrittenJsonConverter", "the attribute JsonConverter")] @@ -2045,6 +2046,13 @@ public sealed partial record OverTryFormatFieldBase : TryFormatFieldBase, IValue public readonly partial record struct CompareToAsField : IValue { public static int CompareTo = 1; } + // A [GeneratedMember] written by hand would make the member read as generated. + public readonly partial record struct MarkedByHand : IValue + { + [CodoMetis.TypeKit.CompilerServices.GeneratedMember(typeof(IValue), "Hidden")] + public static int Hidden() => 1; + } + // What C#'s overloading and hiding keep apart from a generated member, which builds beside it (decision 128). public abstract record NullableTryFromBase { public static Option TryFrom(int? value) => Option.None(); } diff --git a/test/CodoMetis.TypeKit.Generators.Tests/GeneratedMemberAttributeTests.cs b/test/CodoMetis.TypeKit.Generators.Tests/GeneratedMemberAttributeTests.cs new file mode 100644 index 0000000..1019c3f --- /dev/null +++ b/test/CodoMetis.TypeKit.Generators.Tests/GeneratedMemberAttributeTests.cs @@ -0,0 +1,85 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using CodoMetis.TypeKit.ClosedSets; +using CodoMetis.TypeKit.CompilerServices; +using CodoMetis.TypeKit.Generators.Probes; +using CodoMetis.TypeKit.ValueObjects; + +namespace CodoMetis.TypeKit.Generators.Tests; + +/// +/// Every member the generators introduce carries , and no member written by hand +/// does, in this assembly and in the probes' (decision 128). It is how a member is told generated from hand-written +/// without a list of names, so a member introduced without it reads as the user's, and a check that asks would +/// refuse or keep it as one. +/// +public sealed class GeneratedMemberAttributeTests +{ + private const BindingFlags Declared = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly; + + /// + /// What C# synthesizes for a record, which carries [CompilerGenerated] as the generated members do. Where the + /// generators replace one in its own type (a value object's ToString(), and Equals and + /// GetHashCode() over a base record), Metalama writes the override over the implicit declaration and applies + /// no attribute to it, nor introduces one there (measured 2026-10-31), so it carries neither. + /// + private static bool IsRecordMember(MemberInfo member) => + member switch + { + MethodInfo method => (method.Name, method.GetParameters().Length) is ("ToString", 0) or ("Equals", 1) or ("GetHashCode", 0) or ("PrintMembers", 1) + or ("op_Equality", 2) or ("op_Inequality", 2) or ("get_EqualityContract", 0), + PropertyInfo property => property.Name == "EqualityContract", + ConstructorInfo constructor => constructor.GetParameters() is [{ } original] && original.ParameterType == constructor.DeclaringType, + _ => false + }; + + public static TheoryData Generated => + [ + .. new[] { typeof(ProbeId).Assembly, typeof(GeneratedMemberAttributeTests).Assembly } + .SelectMany(assembly => assembly.GetTypes()) + .Where(type => type.GetInterfaces().Any(i => i.IsGenericType && (i.GetGenericTypeDefinition() == typeof(IValueObject<,>) || i.GetGenericTypeDefinition() == typeof(IClosedSet<>)))) + .Where(type => !type.IsInterface) + ]; + + [Fact] + public void The_generated_types_are_found() => Generated.Count.ShouldBeGreaterThanOrEqualTo(80); + + /// + /// The aspects put [CompilerGenerated] on what they introduce, and the attribute beside it: one without the + /// other is a member introduced past or CodeAnnotations.GeneratedMember. + /// + [Theory] + [MemberData(nameof(Generated))] + public void Every_generated_member_carries_the_attribute_and_no_hand_written_one_does(Type type) + { + var members = type.GetMembers(Declared) + .Where(member => member is not MethodInfo { IsSpecialName: true } method || method.Name.StartsWith("op_", StringComparison.Ordinal)) + .Where(member => !member.Name.StartsWith('<')) + .Where(member => !IsRecordMember(member)) + .Where(member => member is not FieldInfo field || !field.Name.EndsWith("k__BackingField", StringComparison.Ordinal)); + + var wrong = members.Where(member => member.IsDefined(typeof(CompilerGeneratedAttribute), false) != member.IsDefined(typeof(GeneratedMemberAttribute), false)) + .Select(member => $"{member.MemberType} {member}") + .ToList(); + + wrong.ShouldBeEmpty($"{type} has members with [CompilerGenerated] and no [GeneratedMember], or the other way round"); + } + + /// The companion's extension methods are generated too, and name the property they read. + [Fact] + public void The_companion_s_methods_name_the_value_they_read() + { + var getValue = typeof(ProbeAmountExtensions).GetMethod(nameof(ProbeAmountExtensions.GetValue))!.GetCustomAttribute().ShouldNotBeNull(); + + getValue.Contract.ShouldBe(typeof(IValueObject)); + getValue.Member.ShouldBe(nameof(IValueObject<,>.Value)); + } + + /// A member a probe writes by hand, a seam among them, carries none: Create, and a hand-written ToString(). + [Fact] + public void A_hand_written_member_of_another_assembly_carries_none() + { + typeof(ProbeArticle).GetMethod(nameof(ProbeArticle.Create))!.IsDefined(typeof(GeneratedMemberAttribute), false).ShouldBeFalse(); + typeof(ProbeArticle).GetProperty(nameof(ProbeArticle.Value))!.IsDefined(typeof(GeneratedMemberAttribute), false).ShouldBeTrue(); + } +} diff --git a/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurface.verified.txt b/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurface.verified.txt index 21b0c3a..993737d 100644 --- a/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurface.verified.txt +++ b/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurface.verified.txt @@ -2,16 +2,16 @@ IProbeSetNames implements IClosedSet ProbeAmount - CompareTo(Object) : Int32 - CompareTo(ProbeAmount) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeAmount) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeAmount) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Decimal + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Decimal [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -33,36 +33,36 @@ ProbeAmount implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeAmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeAmountTypeConverter : TypeConverter + nested ProbeAmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeAmountJsonConverter] + nested ProbeAmountTypeConverter : TypeConverter [IValue.ProbeAmountTypeConverter] new() - static From(Decimal) : ProbeAmount - static MaxValue : ProbeAmount - static MinValue : ProbeAmount - static Parse(ReadOnlySpan, IFormatProvider) : ProbeAmount - static Parse(ReadOnlySpan, IFormatProvider) : ProbeAmount - static Parse(String, IFormatProvider) : ProbeAmount - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeAmount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeAmount) : Boolean - static TryParse(String, IFormatProvider, out ProbeAmount) : Boolean + static From(Decimal) : ProbeAmount [IPlainValueObject.From] + static MaxValue : ProbeAmount [IMinMaxValue.MaxValue] + static MinValue : ProbeAmount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeAmount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeAmount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeAmount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeAmount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeAmount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeAmount) : Boolean [IParsable.TryParse] static op_Equality(ProbeAmount, ProbeAmount) : Boolean - static op_GreaterThan(ProbeAmount, ProbeAmount) : Boolean - static op_GreaterThanOrEqual(ProbeAmount, ProbeAmount) : Boolean + static op_GreaterThan(ProbeAmount, ProbeAmount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeAmount, ProbeAmount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeAmount, ProbeAmount) : Boolean - static op_LessThan(ProbeAmount, ProbeAmount) : Boolean - static op_LessThanOrEqual(ProbeAmount, ProbeAmount) : Boolean - extension static ProbeAmountExtensions.GetValue(ProbeAmount) : Decimal - extension static ProbeAmountExtensions.ValueOrNull(ProbeAmount?) : Decimal? + static op_LessThan(ProbeAmount, ProbeAmount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeAmount, ProbeAmount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeAmountExtensions.GetValue(ProbeAmount) : Decimal [IValueObject.Value] + extension static ProbeAmountExtensions.ValueOrNull(ProbeAmount?) : Decimal? [IValueObject.Value] ProbeArticle - CompareTo(Object) : Int32 - CompareTo(ProbeArticle) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeArticle) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeArticle) : Boolean GetHashCode() : Int32 - Revalidate() : Result + Revalidate() : Result [IValidatedValue.Revalidate] ToString() : String - ToString(String, IFormatProvider) : String - Value : String + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : String [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -79,31 +79,31 @@ ProbeArticle implements IValidatedValue implements IValueObject implements IValueObjectMaterializer - nested ProbeArticleJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeArticleTypeConverter : TypeConverter + nested ProbeArticleJsonConverter : JsonConverter, IStoredJsonConverterSource [IValidatedValue.ProbeArticleJsonConverter] + nested ProbeArticleTypeConverter : TypeConverter [IValidatedValue.ProbeArticleTypeConverter] new() static Create(String) : Result - static FromKnownGood(String, String) : ProbeArticle - static Parse(ReadOnlySpan, IFormatProvider) : ProbeArticle - static Parse(String, IFormatProvider) : ProbeArticle - static TryFrom(String) : Option - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeArticle) : Boolean - static TryParse(String, IFormatProvider, out ProbeArticle) : Boolean + static FromKnownGood(String, String) : ProbeArticle [IValidatedValue.FromKnownGood] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeArticle [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeArticle [IParsable.Parse] + static TryFrom(String) : Option [IValidatedValue.TryFrom] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeArticle) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeArticle) : Boolean [IParsable.TryParse] static op_Equality(ProbeArticle, ProbeArticle) : Boolean - static op_GreaterThan(ProbeArticle, ProbeArticle) : Boolean - static op_GreaterThanOrEqual(ProbeArticle, ProbeArticle) : Boolean + static op_GreaterThan(ProbeArticle, ProbeArticle) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeArticle, ProbeArticle) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeArticle, ProbeArticle) : Boolean - static op_LessThan(ProbeArticle, ProbeArticle) : Boolean - static op_LessThanOrEqual(ProbeArticle, ProbeArticle) : Boolean - extension static ProbeArticleExtensions.GetValue(ProbeArticle) : String - extension static ProbeArticleExtensions.ValueOrNull(ProbeArticle?) : String + static op_LessThan(ProbeArticle, ProbeArticle) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeArticle, ProbeArticle) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeArticleExtensions.GetValue(ProbeArticle) : String [IValueObject.Value] + extension static ProbeArticleExtensions.ValueOrNull(ProbeArticle?) : String [IValueObject.Value] ProbeArticleFault Description : String Kind : FaultKind - Match(Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute @@ -112,23 +112,23 @@ ProbeArticleFault implements IFault implements IFaultSet implements IParsable - nested ProbeArticleFaultJsonConverter : JsonConverter - nested ProbeArticleFaultTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : ProbeArticleFault - static Parse(String, Boolean) : ProbeArticleFault - static TryParse(String, Boolean, out ProbeArticleFault) : Boolean - static TryParse(String, out ProbeArticleFault) : Boolean + nested ProbeArticleFaultJsonConverter : JsonConverter [IClosedSet.ProbeArticleFaultJsonConverter] + nested ProbeArticleFaultTypeConverter : TypeConverter [IClosedSet.ProbeArticleFaultTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : ProbeArticleFault [IClosedSet.Parse] + static Parse(String, Boolean) : ProbeArticleFault [IClosedSet.Parse] + static TryParse(String, Boolean, out ProbeArticleFault) : Boolean [IClosedSet.TryParse] + static TryParse(String, out ProbeArticleFault) : Boolean [IClosedSet.TryParse] ProbeCode - CompareTo(Object) : Int32 - CompareTo(ProbeCode) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeCode) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeCode) : Boolean GetHashCode() : Int32 - Revalidate() : Result + Revalidate() : Result [IValidatedValue.Revalidate] ToString() : String - ToString(String, IFormatProvider) : String - Value : String + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : String [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -145,31 +145,31 @@ ProbeCode implements IValidatedValue implements IValueObject implements IValueObjectMaterializer - nested ProbeCodeJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeCodeTypeConverter : TypeConverter + nested ProbeCodeJsonConverter : JsonConverter, IStoredJsonConverterSource [IValidatedValue.ProbeCodeJsonConverter] + nested ProbeCodeTypeConverter : TypeConverter [IValidatedValue.ProbeCodeTypeConverter] new() static Create(String) : Result - static FromKnownGood(String, String) : ProbeCode - static Parse(ReadOnlySpan, IFormatProvider) : ProbeCode - static Parse(String, IFormatProvider) : ProbeCode - static TryFrom(String) : Option - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeCode) : Boolean - static TryParse(String, IFormatProvider, out ProbeCode) : Boolean + static FromKnownGood(String, String) : ProbeCode [IValidatedValue.FromKnownGood] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeCode [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeCode [IParsable.Parse] + static TryFrom(String) : Option [IValidatedValue.TryFrom] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeCode) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeCode) : Boolean [IParsable.TryParse] static op_Equality(ProbeCode, ProbeCode) : Boolean - static op_GreaterThan(ProbeCode, ProbeCode) : Boolean - static op_GreaterThanOrEqual(ProbeCode, ProbeCode) : Boolean + static op_GreaterThan(ProbeCode, ProbeCode) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeCode, ProbeCode) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeCode, ProbeCode) : Boolean - static op_LessThan(ProbeCode, ProbeCode) : Boolean - static op_LessThanOrEqual(ProbeCode, ProbeCode) : Boolean - extension static ProbeCodeExtensions.GetValue(ProbeCode) : String - extension static ProbeCodeExtensions.ValueOrNull(ProbeCode?) : String + static op_LessThan(ProbeCode, ProbeCode) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeCode, ProbeCode) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeCodeExtensions.GetValue(ProbeCode) : String [IValueObject.Value] + extension static ProbeCodeExtensions.ValueOrNull(ProbeCode?) : String [IValueObject.Value] ProbeConcurrencyFault Description : String Kind : FaultKind - Match(Func, Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute @@ -178,24 +178,24 @@ ProbeConcurrencyFault implements IFault implements IFaultSet implements IParsable - nested ProbeConcurrencyFaultJsonConverter : JsonConverter - nested ProbeConcurrencyFaultTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : ProbeConcurrencyFault - static Parse(String, Boolean) : ProbeConcurrencyFault - static TryParse(String, Boolean, out ProbeConcurrencyFault) : Boolean - static TryParse(String, out ProbeConcurrencyFault) : Boolean + nested ProbeConcurrencyFaultJsonConverter : JsonConverter [IClosedSet.ProbeConcurrencyFaultJsonConverter] + nested ProbeConcurrencyFaultTypeConverter : TypeConverter [IClosedSet.ProbeConcurrencyFaultTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : ProbeConcurrencyFault [IClosedSet.Parse] + static Parse(String, Boolean) : ProbeConcurrencyFault [IClosedSet.Parse] + static TryParse(String, Boolean, out ProbeConcurrencyFault) : Boolean [IClosedSet.TryParse] + static TryParse(String, out ProbeConcurrencyFault) : Boolean [IClosedSet.TryParse] ProbeContainer.NestedId - CompareTo(Object) : Int32 - CompareTo(ProbeContainer.NestedId) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeContainer.NestedId) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeContainer.NestedId) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -217,37 +217,37 @@ ProbeContainer.NestedId implements IValue implements IValueObject implements IValueObjectMaterializer - nested NestedIdJsonConverter : JsonConverter, IStoredJsonConverterSource - nested NestedIdTypeConverter : TypeConverter + nested NestedIdJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.NestedIdJsonConverter] + nested NestedIdTypeConverter : TypeConverter [IValue.NestedIdTypeConverter] new() - static From(Int32) : ProbeContainer.NestedId - static MaxValue : ProbeContainer.NestedId - static MinValue : ProbeContainer.NestedId - static Parse(ReadOnlySpan, IFormatProvider) : ProbeContainer.NestedId - static Parse(ReadOnlySpan, IFormatProvider) : ProbeContainer.NestedId - static Parse(String, IFormatProvider) : ProbeContainer.NestedId - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeContainer.NestedId) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeContainer.NestedId) : Boolean - static TryParse(String, IFormatProvider, out ProbeContainer.NestedId) : Boolean + static From(Int32) : ProbeContainer.NestedId [IPlainValueObject.From] + static MaxValue : ProbeContainer.NestedId [IMinMaxValue.MaxValue] + static MinValue : ProbeContainer.NestedId [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeContainer.NestedId [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeContainer.NestedId [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeContainer.NestedId [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeContainer.NestedId) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeContainer.NestedId) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeContainer.NestedId) : Boolean [IParsable.TryParse] static op_Equality(ProbeContainer.NestedId, ProbeContainer.NestedId) : Boolean - static op_GreaterThan(ProbeContainer.NestedId, ProbeContainer.NestedId) : Boolean - static op_GreaterThanOrEqual(ProbeContainer.NestedId, ProbeContainer.NestedId) : Boolean + static op_GreaterThan(ProbeContainer.NestedId, ProbeContainer.NestedId) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeContainer.NestedId, ProbeContainer.NestedId) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeContainer.NestedId, ProbeContainer.NestedId) : Boolean - static op_LessThan(ProbeContainer.NestedId, ProbeContainer.NestedId) : Boolean - static op_LessThanOrEqual(ProbeContainer.NestedId, ProbeContainer.NestedId) : Boolean - extension static ProbeContainerNestedIdExtensions.GetValue(ProbeContainer.NestedId) : Int32 - extension static ProbeContainerNestedIdExtensions.ValueOrNull(ProbeContainer.NestedId?) : Int32? + static op_LessThan(ProbeContainer.NestedId, ProbeContainer.NestedId) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeContainer.NestedId, ProbeContainer.NestedId) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeContainerNestedIdExtensions.GetValue(ProbeContainer.NestedId) : Int32 [IValueObject.Value] + extension static ProbeContainerNestedIdExtensions.ValueOrNull(ProbeContainer.NestedId?) : Int32? [IValueObject.Value] ProbeCount - CompareTo(Object) : Int32 - CompareTo(ProbeCount) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeCount) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeCount) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -269,37 +269,37 @@ ProbeCount implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeCountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeCountTypeConverter : TypeConverter + nested ProbeCountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeCountJsonConverter] + nested ProbeCountTypeConverter : TypeConverter [IValue.ProbeCountTypeConverter] new() - static From(Int32) : ProbeCount - static MaxValue : ProbeCount - static MinValue : ProbeCount - static Parse(ReadOnlySpan, IFormatProvider) : ProbeCount - static Parse(ReadOnlySpan, IFormatProvider) : ProbeCount - static Parse(String, IFormatProvider) : ProbeCount - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeCount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeCount) : Boolean - static TryParse(String, IFormatProvider, out ProbeCount) : Boolean + static From(Int32) : ProbeCount [IPlainValueObject.From] + static MaxValue : ProbeCount [IMinMaxValue.MaxValue] + static MinValue : ProbeCount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeCount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeCount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeCount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeCount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeCount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeCount) : Boolean [IParsable.TryParse] static op_Equality(ProbeCount, ProbeCount) : Boolean - static op_GreaterThan(ProbeCount, ProbeCount) : Boolean - static op_GreaterThanOrEqual(ProbeCount, ProbeCount) : Boolean + static op_GreaterThan(ProbeCount, ProbeCount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeCount, ProbeCount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeCount, ProbeCount) : Boolean - static op_LessThan(ProbeCount, ProbeCount) : Boolean - static op_LessThanOrEqual(ProbeCount, ProbeCount) : Boolean - extension static ProbeCountExtensions.GetValue(ProbeCount) : Int32 - extension static ProbeCountExtensions.ValueOrNull(ProbeCount?) : Int32? + static op_LessThan(ProbeCount, ProbeCount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeCount, ProbeCount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeCountExtensions.GetValue(ProbeCount) : Int32 [IValueObject.Value] + extension static ProbeCountExtensions.ValueOrNull(ProbeCount?) : Int32? [IValueObject.Value] ProbeCustomerId - CompareTo(Object) : Int32 - CompareTo(ProbeCustomerId) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeCustomerId) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeCustomerId) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Guid + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Guid [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -320,35 +320,35 @@ ProbeCustomerId implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeCustomerIdJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeCustomerIdTypeConverter : TypeConverter + nested ProbeCustomerIdJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeCustomerIdJsonConverter] + nested ProbeCustomerIdTypeConverter : TypeConverter [IValue.ProbeCustomerIdTypeConverter] new() - static From(Guid) : ProbeCustomerId - static Parse(ReadOnlySpan, IFormatProvider) : ProbeCustomerId - static Parse(ReadOnlySpan, IFormatProvider) : ProbeCustomerId - static Parse(String, IFormatProvider) : ProbeCustomerId - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeCustomerId) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeCustomerId) : Boolean - static TryParse(String, IFormatProvider, out ProbeCustomerId) : Boolean + static From(Guid) : ProbeCustomerId [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeCustomerId [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeCustomerId [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeCustomerId [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeCustomerId) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeCustomerId) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeCustomerId) : Boolean [IParsable.TryParse] static op_Equality(ProbeCustomerId, ProbeCustomerId) : Boolean - static op_GreaterThan(ProbeCustomerId, ProbeCustomerId) : Boolean - static op_GreaterThanOrEqual(ProbeCustomerId, ProbeCustomerId) : Boolean + static op_GreaterThan(ProbeCustomerId, ProbeCustomerId) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeCustomerId, ProbeCustomerId) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeCustomerId, ProbeCustomerId) : Boolean - static op_LessThan(ProbeCustomerId, ProbeCustomerId) : Boolean - static op_LessThanOrEqual(ProbeCustomerId, ProbeCustomerId) : Boolean - extension static ProbeCustomerIdExtensions.GetValue(ProbeCustomerId) : Guid - extension static ProbeCustomerIdExtensions.ValueOrNull(ProbeCustomerId?) : Guid? + static op_LessThan(ProbeCustomerId, ProbeCustomerId) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeCustomerId, ProbeCustomerId) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeCustomerIdExtensions.GetValue(ProbeCustomerId) : Guid [IValueObject.Value] + extension static ProbeCustomerIdExtensions.ValueOrNull(ProbeCustomerId?) : Guid? [IValueObject.Value] ProbeDate - CompareTo(Object) : Int32 - CompareTo(ProbeDate) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeDate) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeDate) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : DateOnly + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : DateOnly [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -368,35 +368,35 @@ ProbeDate implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeDateJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeDateTypeConverter : TypeConverter + nested ProbeDateJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeDateJsonConverter] + nested ProbeDateTypeConverter : TypeConverter [IValue.ProbeDateTypeConverter] new() - static From(DateOnly) : ProbeDate - static MaxValue : ProbeDate - static MinValue : ProbeDate - static Parse(ReadOnlySpan, IFormatProvider) : ProbeDate - static Parse(String, IFormatProvider) : ProbeDate - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeDate) : Boolean - static TryParse(String, IFormatProvider, out ProbeDate) : Boolean + static From(DateOnly) : ProbeDate [IPlainValueObject.From] + static MaxValue : ProbeDate [IMinMaxValue.MaxValue] + static MinValue : ProbeDate [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeDate [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeDate [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeDate) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeDate) : Boolean [IParsable.TryParse] static op_Equality(ProbeDate, ProbeDate) : Boolean - static op_GreaterThan(ProbeDate, ProbeDate) : Boolean - static op_GreaterThanOrEqual(ProbeDate, ProbeDate) : Boolean + static op_GreaterThan(ProbeDate, ProbeDate) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeDate, ProbeDate) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeDate, ProbeDate) : Boolean - static op_LessThan(ProbeDate, ProbeDate) : Boolean - static op_LessThanOrEqual(ProbeDate, ProbeDate) : Boolean - extension static ProbeDateExtensions.GetValue(ProbeDate) : DateOnly - extension static ProbeDateExtensions.ValueOrNull(ProbeDate?) : DateOnly? + static op_LessThan(ProbeDate, ProbeDate) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeDate, ProbeDate) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeDateExtensions.GetValue(ProbeDate) : DateOnly [IValueObject.Value] + extension static ProbeDateExtensions.ValueOrNull(ProbeDate?) : DateOnly? [IValueObject.Value] ProbeDescending - CompareTo(Object) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] CompareTo(ProbeDescending) : Int32 Equals(Object) : Boolean Equals(ProbeDescending) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute HandWrittenOrderingAttribute @@ -419,37 +419,37 @@ ProbeDescending implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeDescendingJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeDescendingTypeConverter : TypeConverter + nested ProbeDescendingJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeDescendingJsonConverter] + nested ProbeDescendingTypeConverter : TypeConverter [IValue.ProbeDescendingTypeConverter] new() - static From(Int32) : ProbeDescending - static MaxValue : ProbeDescending - static MinValue : ProbeDescending - static Parse(ReadOnlySpan, IFormatProvider) : ProbeDescending - static Parse(ReadOnlySpan, IFormatProvider) : ProbeDescending - static Parse(String, IFormatProvider) : ProbeDescending - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeDescending) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeDescending) : Boolean - static TryParse(String, IFormatProvider, out ProbeDescending) : Boolean + static From(Int32) : ProbeDescending [IPlainValueObject.From] + static MaxValue : ProbeDescending [IMinMaxValue.MaxValue] + static MinValue : ProbeDescending [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeDescending [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeDescending [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeDescending [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeDescending) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeDescending) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeDescending) : Boolean [IParsable.TryParse] static op_Equality(ProbeDescending, ProbeDescending) : Boolean - static op_GreaterThan(ProbeDescending, ProbeDescending) : Boolean - static op_GreaterThanOrEqual(ProbeDescending, ProbeDescending) : Boolean + static op_GreaterThan(ProbeDescending, ProbeDescending) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeDescending, ProbeDescending) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeDescending, ProbeDescending) : Boolean - static op_LessThan(ProbeDescending, ProbeDescending) : Boolean - static op_LessThanOrEqual(ProbeDescending, ProbeDescending) : Boolean - extension static ProbeDescendingExtensions.GetValue(ProbeDescending) : Int32 - extension static ProbeDescendingExtensions.ValueOrNull(ProbeDescending?) : Int32? + static op_LessThan(ProbeDescending, ProbeDescending) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeDescending, ProbeDescending) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeDescendingExtensions.GetValue(ProbeDescending) : Int32 [IValueObject.Value] + extension static ProbeDescendingExtensions.ValueOrNull(ProbeDescending?) : Int32? [IValueObject.Value] ProbeDuration - CompareTo(Object) : Int32 - CompareTo(ProbeDuration) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeDuration) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeDuration) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : TimeSpan + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : TimeSpan [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -469,33 +469,33 @@ ProbeDuration implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeDurationJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeDurationTypeConverter : TypeConverter + nested ProbeDurationJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeDurationJsonConverter] + nested ProbeDurationTypeConverter : TypeConverter [IValue.ProbeDurationTypeConverter] new() - static From(TimeSpan) : ProbeDuration - static MaxValue : ProbeDuration - static MinValue : ProbeDuration - static Parse(ReadOnlySpan, IFormatProvider) : ProbeDuration - static Parse(String, IFormatProvider) : ProbeDuration - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeDuration) : Boolean - static TryParse(String, IFormatProvider, out ProbeDuration) : Boolean + static From(TimeSpan) : ProbeDuration [IPlainValueObject.From] + static MaxValue : ProbeDuration [IMinMaxValue.MaxValue] + static MinValue : ProbeDuration [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeDuration [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeDuration [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeDuration) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeDuration) : Boolean [IParsable.TryParse] static op_Equality(ProbeDuration, ProbeDuration) : Boolean - static op_GreaterThan(ProbeDuration, ProbeDuration) : Boolean - static op_GreaterThanOrEqual(ProbeDuration, ProbeDuration) : Boolean + static op_GreaterThan(ProbeDuration, ProbeDuration) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeDuration, ProbeDuration) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeDuration, ProbeDuration) : Boolean - static op_LessThan(ProbeDuration, ProbeDuration) : Boolean - static op_LessThanOrEqual(ProbeDuration, ProbeDuration) : Boolean - extension static ProbeDurationExtensions.GetValue(ProbeDuration) : TimeSpan - extension static ProbeDurationExtensions.ValueOrNull(ProbeDuration?) : TimeSpan? + static op_LessThan(ProbeDuration, ProbeDuration) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeDuration, ProbeDuration) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeDurationExtensions.GetValue(ProbeDuration) : TimeSpan [IValueObject.Value] + extension static ProbeDurationExtensions.ValueOrNull(ProbeDuration?) : TimeSpan? [IValueObject.Value] ProbeFlag - CompareTo(Object) : Int32 - CompareTo(ProbeFlag) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeFlag) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeFlag) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : Boolean + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : Boolean [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -513,33 +513,33 @@ ProbeFlag implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeFlagJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeFlagTypeConverter : TypeConverter + nested ProbeFlagJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeFlagJsonConverter] + nested ProbeFlagTypeConverter : TypeConverter [IValue.ProbeFlagTypeConverter] new() - static From(Boolean) : ProbeFlag - static Parse(ReadOnlySpan, IFormatProvider) : ProbeFlag - static Parse(String, IFormatProvider) : ProbeFlag - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeFlag) : Boolean - static TryParse(String, IFormatProvider, out ProbeFlag) : Boolean + static From(Boolean) : ProbeFlag [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeFlag [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeFlag [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeFlag) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeFlag) : Boolean [IParsable.TryParse] static op_Equality(ProbeFlag, ProbeFlag) : Boolean - static op_GreaterThan(ProbeFlag, ProbeFlag) : Boolean - static op_GreaterThanOrEqual(ProbeFlag, ProbeFlag) : Boolean + static op_GreaterThan(ProbeFlag, ProbeFlag) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeFlag, ProbeFlag) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeFlag, ProbeFlag) : Boolean - static op_LessThan(ProbeFlag, ProbeFlag) : Boolean - static op_LessThanOrEqual(ProbeFlag, ProbeFlag) : Boolean - extension static ProbeFlagExtensions.GetValue(ProbeFlag) : Boolean - extension static ProbeFlagExtensions.ValueOrNull(ProbeFlag?) : Boolean? + static op_LessThan(ProbeFlag, ProbeFlag) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeFlag, ProbeFlag) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeFlagExtensions.GetValue(ProbeFlag) : Boolean [IValueObject.Value] + extension static ProbeFlagExtensions.ValueOrNull(ProbeFlag?) : Boolean? [IValueObject.Value] ProbeId - CompareTo(Object) : Int32 - CompareTo(ProbeId) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeId) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeId) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Guid + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Guid [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -559,33 +559,33 @@ ProbeId implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeIdJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeIdTypeConverter : TypeConverter + nested ProbeIdJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeIdJsonConverter] + nested ProbeIdTypeConverter : TypeConverter [IValue.ProbeIdTypeConverter] new() - static From(Guid) : ProbeId - static Parse(ReadOnlySpan, IFormatProvider) : ProbeId - static Parse(ReadOnlySpan, IFormatProvider) : ProbeId - static Parse(String, IFormatProvider) : ProbeId - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeId) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeId) : Boolean - static TryParse(String, IFormatProvider, out ProbeId) : Boolean + static From(Guid) : ProbeId [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeId [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeId [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeId [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeId) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeId) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeId) : Boolean [IParsable.TryParse] static op_Equality(ProbeId, ProbeId) : Boolean - static op_GreaterThan(ProbeId, ProbeId) : Boolean - static op_GreaterThanOrEqual(ProbeId, ProbeId) : Boolean + static op_GreaterThan(ProbeId, ProbeId) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeId, ProbeId) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeId, ProbeId) : Boolean - static op_LessThan(ProbeId, ProbeId) : Boolean - static op_LessThanOrEqual(ProbeId, ProbeId) : Boolean - extension static ProbeIdExtensions.GetValue(ProbeId) : Guid - extension static ProbeIdExtensions.ValueOrNull(ProbeId?) : Guid? + static op_LessThan(ProbeId, ProbeId) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeId, ProbeId) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeIdExtensions.GetValue(ProbeId) : Guid [IValueObject.Value] + extension static ProbeIdExtensions.ValueOrNull(ProbeId?) : Guid? [IValueObject.Value] ProbeInstant - CompareTo(Object) : Int32 - CompareTo(ProbeInstant) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeInstant) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeInstant) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : Instant + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : Instant [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -602,33 +602,33 @@ ProbeInstant implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeInstantJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeInstantTypeConverter : TypeConverter + nested ProbeInstantJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeInstantJsonConverter] + nested ProbeInstantTypeConverter : TypeConverter [IValue.ProbeInstantTypeConverter] new() - static From(Instant) : ProbeInstant - static MaxValue : ProbeInstant - static MinValue : ProbeInstant - static Parse(String, IFormatProvider) : ProbeInstant - static TryParse(String, IFormatProvider, out ProbeInstant) : Boolean + static From(Instant) : ProbeInstant [IPlainValueObject.From] + static MaxValue : ProbeInstant [IMinMaxValue.MaxValue] + static MinValue : ProbeInstant [IMinMaxValue.MinValue] + static Parse(String, IFormatProvider) : ProbeInstant [IParsable.Parse] + static TryParse(String, IFormatProvider, out ProbeInstant) : Boolean [IParsable.TryParse] static op_Equality(ProbeInstant, ProbeInstant) : Boolean - static op_GreaterThan(ProbeInstant, ProbeInstant) : Boolean - static op_GreaterThanOrEqual(ProbeInstant, ProbeInstant) : Boolean + static op_GreaterThan(ProbeInstant, ProbeInstant) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeInstant, ProbeInstant) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeInstant, ProbeInstant) : Boolean - static op_LessThan(ProbeInstant, ProbeInstant) : Boolean - static op_LessThanOrEqual(ProbeInstant, ProbeInstant) : Boolean - extension static ProbeInstantExtensions.GetValue(ProbeInstant) : Instant - extension static ProbeInstantExtensions.ValueOrNull(ProbeInstant?) : Instant? + static op_LessThan(ProbeInstant, ProbeInstant) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeInstant, ProbeInstant) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeInstantExtensions.GetValue(ProbeInstant) : Instant [IValueObject.Value] + extension static ProbeInstantExtensions.ValueOrNull(ProbeInstant?) : Instant? [IValueObject.Value] ProbeInternalId (internal) - CompareTo(Object) : Int32 - CompareTo(ProbeInternalId) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeInternalId) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeInternalId) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -650,33 +650,33 @@ ProbeInternalId (internal) implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeInternalIdJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeInternalIdTypeConverter : TypeConverter + nested ProbeInternalIdJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeInternalIdJsonConverter] + nested ProbeInternalIdTypeConverter : TypeConverter [IValue.ProbeInternalIdTypeConverter] new() - static From(Int32) : ProbeInternalId - static MaxValue : ProbeInternalId - static MinValue : ProbeInternalId - static Parse(ReadOnlySpan, IFormatProvider) : ProbeInternalId - static Parse(ReadOnlySpan, IFormatProvider) : ProbeInternalId - static Parse(String, IFormatProvider) : ProbeInternalId - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeInternalId) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeInternalId) : Boolean - static TryParse(String, IFormatProvider, out ProbeInternalId) : Boolean + static From(Int32) : ProbeInternalId [IPlainValueObject.From] + static MaxValue : ProbeInternalId [IMinMaxValue.MaxValue] + static MinValue : ProbeInternalId [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeInternalId [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeInternalId [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeInternalId [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeInternalId) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeInternalId) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeInternalId) : Boolean [IParsable.TryParse] static op_Equality(ProbeInternalId, ProbeInternalId) : Boolean - static op_GreaterThan(ProbeInternalId, ProbeInternalId) : Boolean - static op_GreaterThanOrEqual(ProbeInternalId, ProbeInternalId) : Boolean + static op_GreaterThan(ProbeInternalId, ProbeInternalId) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeInternalId, ProbeInternalId) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeInternalId, ProbeInternalId) : Boolean - static op_LessThan(ProbeInternalId, ProbeInternalId) : Boolean - static op_LessThanOrEqual(ProbeInternalId, ProbeInternalId) : Boolean - extension internal static ProbeInternalIdExtensions.GetValue(ProbeInternalId) : Int32 - extension internal static ProbeInternalIdExtensions.ValueOrNull(ProbeInternalId?) : Int32? + static op_LessThan(ProbeInternalId, ProbeInternalId) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeInternalId, ProbeInternalId) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension internal static ProbeInternalIdExtensions.GetValue(ProbeInternalId) : Int32 [IValueObject.Value] + extension internal static ProbeInternalIdExtensions.ValueOrNull(ProbeInternalId?) : Int32? [IValueObject.Value] ProbeIsbn Equals(Object) : Boolean Equals(ProbeIsbn) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : ProbeIsbnText + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ProbeIsbnText [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -689,40 +689,40 @@ ProbeIsbn implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeIsbnJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeIsbnTypeConverter : TypeConverter + nested ProbeIsbnJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeIsbnJsonConverter] + nested ProbeIsbnTypeConverter : TypeConverter [IValue.ProbeIsbnTypeConverter] new() - static From(ProbeIsbnText) : ProbeIsbn - static Parse(String, IFormatProvider) : ProbeIsbn - static TryParse(String, IFormatProvider, out ProbeIsbn) : Boolean + static From(ProbeIsbnText) : ProbeIsbn [IPlainValueObject.From] + static Parse(String, IFormatProvider) : ProbeIsbn [IParsable.Parse] + static TryParse(String, IFormatProvider, out ProbeIsbn) : Boolean [IParsable.TryParse] static op_Equality(ProbeIsbn, ProbeIsbn) : Boolean static op_Inequality(ProbeIsbn, ProbeIsbn) : Boolean - extension static ProbeIsbnExtensions.GetValue(ProbeIsbn) : ProbeIsbnText - extension static ProbeIsbnExtensions.ValueOrNull(ProbeIsbn?) : ProbeIsbnText + extension static ProbeIsbnExtensions.GetValue(ProbeIsbn) : ProbeIsbnText [IValueObject.Value] + extension static ProbeIsbnExtensions.ValueOrNull(ProbeIsbn?) : ProbeIsbnText [IValueObject.Value] ProbeKeyword - Match(Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested ProbeKeywordJsonConverter : JsonConverter - nested ProbeKeywordTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : ProbeKeyword - static Parse(String, Boolean) : ProbeKeyword - static TryParse(String, Boolean, out ProbeKeyword) : Boolean - static TryParse(String, out ProbeKeyword) : Boolean + nested ProbeKeywordJsonConverter : JsonConverter [IClosedSet.ProbeKeywordJsonConverter] + nested ProbeKeywordTypeConverter : TypeConverter [IClosedSet.ProbeKeywordTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : ProbeKeyword [IClosedSet.Parse] + static Parse(String, Boolean) : ProbeKeyword [IClosedSet.Parse] + static TryParse(String, Boolean, out ProbeKeyword) : Boolean [IClosedSet.TryParse] + static TryParse(String, out ProbeKeyword) : Boolean [IClosedSet.TryParse] ProbeKindlessFault Kind : FaultKind - Match(Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute @@ -731,23 +731,23 @@ ProbeKindlessFault implements IFault implements IFaultSet implements IParsable - nested ProbeKindlessFaultJsonConverter : JsonConverter - nested ProbeKindlessFaultTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : ProbeKindlessFault - static Parse(String, Boolean) : ProbeKindlessFault - static TryParse(String, Boolean, out ProbeKindlessFault) : Boolean - static TryParse(String, out ProbeKindlessFault) : Boolean + nested ProbeKindlessFaultJsonConverter : JsonConverter [IClosedSet.ProbeKindlessFaultJsonConverter] + nested ProbeKindlessFaultTypeConverter : TypeConverter [IClosedSet.ProbeKindlessFaultTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : ProbeKindlessFault [IClosedSet.Parse] + static Parse(String, Boolean) : ProbeKindlessFault [IClosedSet.Parse] + static TryParse(String, Boolean, out ProbeKindlessFault) : Boolean [IClosedSet.TryParse] + static TryParse(String, out ProbeKindlessFault) : Boolean [IClosedSet.TryParse] ProbeLabel $() : ProbeLabel - CompareTo(Object) : Int32 - CompareTo(ProbeLabel) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeLabel) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeLabel) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : String + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : String [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -765,25 +765,25 @@ ProbeLabel implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeLabelJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeLabelTypeConverter : TypeConverter - static From(String) : ProbeLabel - static Parse(ReadOnlySpan, IFormatProvider) : ProbeLabel - static Parse(String, IFormatProvider) : ProbeLabel - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeLabel) : Boolean - static TryParse(String, IFormatProvider, out ProbeLabel) : Boolean + nested ProbeLabelJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeLabelJsonConverter] + nested ProbeLabelTypeConverter : TypeConverter [IValue.ProbeLabelTypeConverter] + static From(String) : ProbeLabel [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeLabel [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeLabel [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeLabel) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeLabel) : Boolean [IParsable.TryParse] static op_Equality(ProbeLabel, ProbeLabel) : Boolean - static op_GreaterThan(ProbeLabel, ProbeLabel) : Boolean - static op_GreaterThanOrEqual(ProbeLabel, ProbeLabel) : Boolean + static op_GreaterThan(ProbeLabel, ProbeLabel) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeLabel, ProbeLabel) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeLabel, ProbeLabel) : Boolean - static op_LessThan(ProbeLabel, ProbeLabel) : Boolean - static op_LessThanOrEqual(ProbeLabel, ProbeLabel) : Boolean - extension static ProbeLabelExtensions.GetValue(ProbeLabel) : String - extension static ProbeLabelExtensions.ValueOrNull(ProbeLabel) : String + static op_LessThan(ProbeLabel, ProbeLabel) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeLabel, ProbeLabel) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeLabelExtensions.GetValue(ProbeLabel) : String [IValueObject.Value] + extension static ProbeLabelExtensions.ValueOrNull(ProbeLabel) : String [IValueObject.Value] ProbeLabelled - Match(Func, Func) : TResult - Name : String - QualifiedName : String + Match(Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] ToString() : String attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute @@ -791,41 +791,41 @@ ProbeLabelled attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested ProbeLabelledJsonConverter : JsonConverter - nested ProbeLabelledTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : ProbeLabelled - static Parse(String, Boolean) : ProbeLabelled - static TryParse(String, Boolean, out ProbeLabelled) : Boolean - static TryParse(String, out ProbeLabelled) : Boolean + nested ProbeLabelledJsonConverter : JsonConverter [IClosedSet.ProbeLabelledJsonConverter] + nested ProbeLabelledTypeConverter : TypeConverter [IClosedSet.ProbeLabelledTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : ProbeLabelled [IClosedSet.Parse] + static Parse(String, Boolean) : ProbeLabelled [IClosedSet.Parse] + static TryParse(String, Boolean, out ProbeLabelled) : Boolean [IClosedSet.TryParse] + static TryParse(String, out ProbeLabelled) : Boolean [IClosedSet.TryParse] ProbeLevel - Match(Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested ProbeLevelJsonConverter : JsonConverter - nested ProbeLevelTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : ProbeLevel - static Parse(String, Boolean) : ProbeLevel - static TryParse(String, Boolean, out ProbeLevel) : Boolean - static TryParse(String, out ProbeLevel) : Boolean + nested ProbeLevelJsonConverter : JsonConverter [IClosedSet.ProbeLevelJsonConverter] + nested ProbeLevelTypeConverter : TypeConverter [IClosedSet.ProbeLevelTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : ProbeLevel [IClosedSet.Parse] + static Parse(String, Boolean) : ProbeLevel [IClosedSet.Parse] + static TryParse(String, Boolean, out ProbeLevel) : Boolean [IClosedSet.TryParse] + static TryParse(String, out ProbeLevel) : Boolean [IClosedSet.TryParse] static Unlisted() : ProbeLevel ProbeLocalDate - CompareTo(Object) : Int32 - CompareTo(ProbeLocalDate) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeLocalDate) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeLocalDate) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : LocalDate + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : LocalDate [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -841,31 +841,31 @@ ProbeLocalDate implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeLocalDateJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeLocalDateTypeConverter : TypeConverter + nested ProbeLocalDateJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeLocalDateJsonConverter] + nested ProbeLocalDateTypeConverter : TypeConverter [IValue.ProbeLocalDateTypeConverter] new() - static From(LocalDate) : ProbeLocalDate - static Parse(String, IFormatProvider) : ProbeLocalDate - static TryParse(String, IFormatProvider, out ProbeLocalDate) : Boolean + static From(LocalDate) : ProbeLocalDate [IPlainValueObject.From] + static Parse(String, IFormatProvider) : ProbeLocalDate [IParsable.Parse] + static TryParse(String, IFormatProvider, out ProbeLocalDate) : Boolean [IParsable.TryParse] static op_Equality(ProbeLocalDate, ProbeLocalDate) : Boolean - static op_GreaterThan(ProbeLocalDate, ProbeLocalDate) : Boolean - static op_GreaterThanOrEqual(ProbeLocalDate, ProbeLocalDate) : Boolean + static op_GreaterThan(ProbeLocalDate, ProbeLocalDate) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeLocalDate, ProbeLocalDate) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeLocalDate, ProbeLocalDate) : Boolean - static op_LessThan(ProbeLocalDate, ProbeLocalDate) : Boolean - static op_LessThanOrEqual(ProbeLocalDate, ProbeLocalDate) : Boolean - extension static ProbeLocalDateExtensions.GetValue(ProbeLocalDate) : LocalDate - extension static ProbeLocalDateExtensions.ValueOrNull(ProbeLocalDate?) : LocalDate? + static op_LessThan(ProbeLocalDate, ProbeLocalDate) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeLocalDate, ProbeLocalDate) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeLocalDateExtensions.GetValue(ProbeLocalDate) : LocalDate [IValueObject.Value] + extension static ProbeLocalDateExtensions.ValueOrNull(ProbeLocalDate?) : LocalDate? [IValueObject.Value] ProbeMoment - CompareTo(Object) : Int32 - CompareTo(ProbeMoment) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeMoment) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeMoment) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : DateTimeOffset + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : DateTimeOffset [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -885,35 +885,35 @@ ProbeMoment implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeMomentJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeMomentTypeConverter : TypeConverter + nested ProbeMomentJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeMomentJsonConverter] + nested ProbeMomentTypeConverter : TypeConverter [IValue.ProbeMomentTypeConverter] new() - static From(DateTimeOffset) : ProbeMoment - static MaxValue : ProbeMoment - static MinValue : ProbeMoment - static Parse(ReadOnlySpan, IFormatProvider) : ProbeMoment - static Parse(String, IFormatProvider) : ProbeMoment - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeMoment) : Boolean - static TryParse(String, IFormatProvider, out ProbeMoment) : Boolean + static From(DateTimeOffset) : ProbeMoment [IPlainValueObject.From] + static MaxValue : ProbeMoment [IMinMaxValue.MaxValue] + static MinValue : ProbeMoment [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeMoment [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeMoment [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeMoment) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeMoment) : Boolean [IParsable.TryParse] static op_Equality(ProbeMoment, ProbeMoment) : Boolean - static op_GreaterThan(ProbeMoment, ProbeMoment) : Boolean - static op_GreaterThanOrEqual(ProbeMoment, ProbeMoment) : Boolean + static op_GreaterThan(ProbeMoment, ProbeMoment) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeMoment, ProbeMoment) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeMoment, ProbeMoment) : Boolean - static op_LessThan(ProbeMoment, ProbeMoment) : Boolean - static op_LessThanOrEqual(ProbeMoment, ProbeMoment) : Boolean - extension static ProbeMomentExtensions.GetValue(ProbeMoment) : DateTimeOffset - extension static ProbeMomentExtensions.ValueOrNull(ProbeMoment?) : DateTimeOffset? + static op_LessThan(ProbeMoment, ProbeMoment) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeMoment, ProbeMoment) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeMomentExtensions.GetValue(ProbeMoment) : DateTimeOffset [IValueObject.Value] + extension static ProbeMomentExtensions.ValueOrNull(ProbeMoment?) : DateTimeOffset? [IValueObject.Value] ProbeMoney - CompareTo(Object) : Int32 - CompareTo(ProbeMoney) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeMoney) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeMoney) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Decimal + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Decimal [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -943,49 +943,49 @@ ProbeMoney implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeMoneyJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeMoneyTypeConverter : TypeConverter + nested ProbeMoneyJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeMoneyJsonConverter] + nested ProbeMoneyTypeConverter : TypeConverter [IValue.ProbeMoneyTypeConverter] new() - static From(Decimal) : ProbeMoney - static MaxValue : ProbeMoney - static MinValue : ProbeMoney - static Parse(ReadOnlySpan, IFormatProvider) : ProbeMoney - static Parse(ReadOnlySpan, IFormatProvider) : ProbeMoney - static Parse(String, IFormatProvider) : ProbeMoney - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeMoney) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeMoney) : Boolean - static TryParse(String, IFormatProvider, out ProbeMoney) : Boolean - static op_Addition(ProbeMoney, ProbeMoney) : ProbeMoney - static op_CheckedAddition(ProbeMoney, ProbeMoney) : ProbeMoney - static op_CheckedDivision(ProbeMoney, Decimal) : ProbeMoney - static op_CheckedDivision(ProbeMoney, ProbeMoney) : Decimal - static op_CheckedMultiply(ProbeMoney, Decimal) : ProbeMoney - static op_CheckedSubtraction(ProbeMoney, ProbeMoney) : ProbeMoney - static op_CheckedUnaryNegation(ProbeMoney) : ProbeMoney - static op_Division(ProbeMoney, Decimal) : ProbeMoney - static op_Division(ProbeMoney, ProbeMoney) : Decimal + static From(Decimal) : ProbeMoney [IPlainValueObject.From] + static MaxValue : ProbeMoney [IMinMaxValue.MaxValue] + static MinValue : ProbeMoney [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeMoney [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeMoney [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeMoney [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeMoney) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeMoney) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeMoney) : Boolean [IParsable.TryParse] + static op_Addition(ProbeMoney, ProbeMoney) : ProbeMoney [IAdditionOperators.op_Addition] + static op_CheckedAddition(ProbeMoney, ProbeMoney) : ProbeMoney [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(ProbeMoney, Decimal) : ProbeMoney [IDivisionOperators.op_CheckedDivision] + static op_CheckedDivision(ProbeMoney, ProbeMoney) : Decimal [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(ProbeMoney, Decimal) : ProbeMoney [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(ProbeMoney, ProbeMoney) : ProbeMoney [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(ProbeMoney) : ProbeMoney [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(ProbeMoney, Decimal) : ProbeMoney [IDivisionOperators.op_Division] + static op_Division(ProbeMoney, ProbeMoney) : Decimal [IDivisionOperators.op_Division] static op_Equality(ProbeMoney, ProbeMoney) : Boolean - static op_GreaterThan(ProbeMoney, ProbeMoney) : Boolean - static op_GreaterThanOrEqual(ProbeMoney, ProbeMoney) : Boolean + static op_GreaterThan(ProbeMoney, ProbeMoney) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeMoney, ProbeMoney) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeMoney, ProbeMoney) : Boolean - static op_LessThan(ProbeMoney, ProbeMoney) : Boolean - static op_LessThanOrEqual(ProbeMoney, ProbeMoney) : Boolean - static op_Modulus(ProbeMoney, Decimal) : ProbeMoney - static op_Multiply(ProbeMoney, Decimal) : ProbeMoney - static op_Subtraction(ProbeMoney, ProbeMoney) : ProbeMoney - static op_UnaryNegation(ProbeMoney) : ProbeMoney - static op_UnaryPlus(ProbeMoney) : ProbeMoney - extension static ProbeMoneyExtensions.GetValue(ProbeMoney) : Decimal - extension static ProbeMoneyExtensions.ValueOrNull(ProbeMoney?) : Decimal? + static op_LessThan(ProbeMoney, ProbeMoney) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeMoney, ProbeMoney) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(ProbeMoney, Decimal) : ProbeMoney [IModulusOperators.op_Modulus] + static op_Multiply(ProbeMoney, Decimal) : ProbeMoney [IMultiplyOperators.op_Multiply] + static op_Subtraction(ProbeMoney, ProbeMoney) : ProbeMoney [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(ProbeMoney) : ProbeMoney [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(ProbeMoney) : ProbeMoney [IUnaryPlusOperators.op_UnaryPlus] + extension static ProbeMoneyExtensions.GetValue(ProbeMoney) : Decimal [IValueObject.Value] + extension static ProbeMoneyExtensions.ValueOrNull(ProbeMoney?) : Decimal? [IValueObject.Value] ProbeName - CompareTo(Object) : Int32 - CompareTo(ProbeName) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeName) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeName) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : String + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : String [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1003,47 +1003,47 @@ ProbeName implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeNameJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeNameTypeConverter : TypeConverter + nested ProbeNameJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeNameJsonConverter] + nested ProbeNameTypeConverter : TypeConverter [IValue.ProbeNameTypeConverter] new() - static From(String) : ProbeName - static Parse(ReadOnlySpan, IFormatProvider) : ProbeName - static Parse(String, IFormatProvider) : ProbeName - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeName) : Boolean - static TryParse(String, IFormatProvider, out ProbeName) : Boolean + static From(String) : ProbeName [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeName [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeName [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeName) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeName) : Boolean [IParsable.TryParse] static op_Equality(ProbeName, ProbeName) : Boolean - static op_GreaterThan(ProbeName, ProbeName) : Boolean - static op_GreaterThanOrEqual(ProbeName, ProbeName) : Boolean + static op_GreaterThan(ProbeName, ProbeName) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeName, ProbeName) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeName, ProbeName) : Boolean - static op_LessThan(ProbeName, ProbeName) : Boolean - static op_LessThanOrEqual(ProbeName, ProbeName) : Boolean - extension static ProbeNameExtensions.GetValue(ProbeName) : String - extension static ProbeNameExtensions.ValueOrNull(ProbeName?) : String + static op_LessThan(ProbeName, ProbeName) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeName, ProbeName) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeNameExtensions.GetValue(ProbeName) : String [IValueObject.Value] + extension static ProbeNameExtensions.ValueOrNull(ProbeName?) : String [IValueObject.Value] ProbeOrder.Status - Match(Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested StatusJsonConverter : JsonConverter - nested StatusTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : ProbeOrder.Status - static Parse(String, Boolean) : ProbeOrder.Status - static TryParse(String, Boolean, out ProbeOrder.Status) : Boolean - static TryParse(String, out ProbeOrder.Status) : Boolean + nested StatusJsonConverter : JsonConverter [IClosedSet.StatusJsonConverter] + nested StatusTypeConverter : TypeConverter [IClosedSet.StatusTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : ProbeOrder.Status [IClosedSet.Parse] + static Parse(String, Boolean) : ProbeOrder.Status [IClosedSet.Parse] + static TryParse(String, Boolean, out ProbeOrder.Status) : Boolean [IClosedSet.TryParse] + static TryParse(String, out ProbeOrder.Status) : Boolean [IClosedSet.TryParse] ProbeOrderFault Description : String Kind : FaultKind - Match(Func, Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute @@ -1052,23 +1052,23 @@ ProbeOrderFault implements IFault implements IFaultSet implements IParsable - nested ProbeOrderFaultJsonConverter : JsonConverter - nested ProbeOrderFaultTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : ProbeOrderFault - static Parse(String, Boolean) : ProbeOrderFault - static TryParse(String, Boolean, out ProbeOrderFault) : Boolean - static TryParse(String, out ProbeOrderFault) : Boolean + nested ProbeOrderFaultJsonConverter : JsonConverter [IClosedSet.ProbeOrderFaultJsonConverter] + nested ProbeOrderFaultTypeConverter : TypeConverter [IClosedSet.ProbeOrderFaultTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : ProbeOrderFault [IClosedSet.Parse] + static Parse(String, Boolean) : ProbeOrderFault [IClosedSet.Parse] + static TryParse(String, Boolean, out ProbeOrderFault) : Boolean [IClosedSet.TryParse] + static TryParse(String, out ProbeOrderFault) : Boolean [IClosedSet.TryParse] ProbeOverride - CompareTo(Object) : Int32 - CompareTo(ProbeOverride) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeOverride) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeOverride) : Boolean GetHashCode() : Int32 - Revalidate() : Result + Revalidate() : Result [IValidatedValue.Revalidate] ToString() : String - ToString(String, IFormatProvider) : String - Value : String + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : String [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1085,36 +1085,36 @@ ProbeOverride implements IValidatedValue implements IValueObject implements IValueObjectMaterializer - nested ProbeOverrideJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeOverrideTypeConverter : TypeConverter + nested ProbeOverrideJsonConverter : JsonConverter, IStoredJsonConverterSource [IValidatedValue.ProbeOverrideJsonConverter] + nested ProbeOverrideTypeConverter : TypeConverter [IValidatedValue.ProbeOverrideTypeConverter] new() static Create(String) : Result - static FromKnownGood(String, String) : ProbeOverride - static Parse(ReadOnlySpan, IFormatProvider) : ProbeOverride - static Parse(String, IFormatProvider) : ProbeOverride + static FromKnownGood(String, String) : ProbeOverride [IValidatedValue.FromKnownGood] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeOverride [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeOverride [IParsable.Parse] static TryFrom(String) : Option - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeOverride) : Boolean - static TryParse(String, IFormatProvider, out ProbeOverride) : Boolean + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeOverride) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeOverride) : Boolean [IParsable.TryParse] static op_Equality(ProbeOverride, ProbeOverride) : Boolean - static op_GreaterThan(ProbeOverride, ProbeOverride) : Boolean - static op_GreaterThanOrEqual(ProbeOverride, ProbeOverride) : Boolean + static op_GreaterThan(ProbeOverride, ProbeOverride) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeOverride, ProbeOverride) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeOverride, ProbeOverride) : Boolean - static op_LessThan(ProbeOverride, ProbeOverride) : Boolean - static op_LessThanOrEqual(ProbeOverride, ProbeOverride) : Boolean - extension static ProbeOverrideExtensions.GetValue(ProbeOverride) : String - extension static ProbeOverrideExtensions.ValueOrNull(ProbeOverride?) : String + static op_LessThan(ProbeOverride, ProbeOverride) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeOverride, ProbeOverride) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeOverrideExtensions.GetValue(ProbeOverride) : String [IValueObject.Value] + extension static ProbeOverrideExtensions.ValueOrNull(ProbeOverride?) : String [IValueObject.Value] ProbePercentage - CompareTo(Object) : Int32 - CompareTo(ProbePercentage) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbePercentage) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbePercentage) : Boolean GetHashCode() : Int32 - Revalidate() : Result + Revalidate() : Result [IValidatedValue.Revalidate] ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1134,34 +1134,34 @@ ProbePercentage implements IValidatedValue implements IValueObject implements IValueObjectMaterializer - nested ProbePercentageJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbePercentageTypeConverter : TypeConverter + nested ProbePercentageJsonConverter : JsonConverter, IStoredJsonConverterSource [IValidatedValue.ProbePercentageJsonConverter] + nested ProbePercentageTypeConverter : TypeConverter [IValidatedValue.ProbePercentageTypeConverter] new() static Create(Int32) : Result - static FromKnownGood(Int32, String) : ProbePercentage - static Parse(ReadOnlySpan, IFormatProvider) : ProbePercentage - static Parse(ReadOnlySpan, IFormatProvider) : ProbePercentage - static Parse(String, IFormatProvider) : ProbePercentage - static TryFrom(Int32) : Option - static TryParse(ReadOnlySpan, IFormatProvider, out ProbePercentage) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ProbePercentage) : Boolean - static TryParse(String, IFormatProvider, out ProbePercentage) : Boolean + static FromKnownGood(Int32, String) : ProbePercentage [IValidatedValue.FromKnownGood] + static Parse(ReadOnlySpan, IFormatProvider) : ProbePercentage [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ProbePercentage [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbePercentage [IParsable.Parse] + static TryFrom(Int32) : Option [IValidatedValue.TryFrom] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbePercentage) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbePercentage) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbePercentage) : Boolean [IParsable.TryParse] static op_Equality(ProbePercentage, ProbePercentage) : Boolean - static op_GreaterThan(ProbePercentage, ProbePercentage) : Boolean - static op_GreaterThanOrEqual(ProbePercentage, ProbePercentage) : Boolean + static op_GreaterThan(ProbePercentage, ProbePercentage) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbePercentage, ProbePercentage) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbePercentage, ProbePercentage) : Boolean - static op_LessThan(ProbePercentage, ProbePercentage) : Boolean - static op_LessThanOrEqual(ProbePercentage, ProbePercentage) : Boolean - extension static ProbePercentageExtensions.GetValue(ProbePercentage) : Int32 - extension static ProbePercentageExtensions.ValueOrNull(ProbePercentage?) : Int32? + static op_LessThan(ProbePercentage, ProbePercentage) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbePercentage, ProbePercentage) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbePercentageExtensions.GetValue(ProbePercentage) : Int32 [IValueObject.Value] + extension static ProbePercentageExtensions.ValueOrNull(ProbePercentage?) : Int32? [IValueObject.Value] ProbePin - CompareTo(Object) : Int32 - CompareTo(ProbePin) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbePin) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbePin) : Boolean GetHashCode() : Int32 ToString() : String - Value : Int32 + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1180,59 +1180,59 @@ ProbePin implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbePinJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbePinTypeConverter : TypeConverter + nested ProbePinJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbePinJsonConverter] + nested ProbePinTypeConverter : TypeConverter [IValue.ProbePinTypeConverter] new() - static From(Int32) : ProbePin - static MaxValue : ProbePin - static MinValue : ProbePin - static Parse(ReadOnlySpan, IFormatProvider) : ProbePin - static Parse(ReadOnlySpan, IFormatProvider) : ProbePin - static Parse(String, IFormatProvider) : ProbePin - static TryParse(ReadOnlySpan, IFormatProvider, out ProbePin) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ProbePin) : Boolean - static TryParse(String, IFormatProvider, out ProbePin) : Boolean + static From(Int32) : ProbePin [IPlainValueObject.From] + static MaxValue : ProbePin [IMinMaxValue.MaxValue] + static MinValue : ProbePin [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ProbePin [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ProbePin [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbePin [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbePin) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbePin) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbePin) : Boolean [IParsable.TryParse] static op_Equality(ProbePin, ProbePin) : Boolean - static op_GreaterThan(ProbePin, ProbePin) : Boolean - static op_GreaterThanOrEqual(ProbePin, ProbePin) : Boolean + static op_GreaterThan(ProbePin, ProbePin) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbePin, ProbePin) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbePin, ProbePin) : Boolean - static op_LessThan(ProbePin, ProbePin) : Boolean - static op_LessThanOrEqual(ProbePin, ProbePin) : Boolean - extension static ProbePinExtensions.GetValue(ProbePin) : Int32 - extension static ProbePinExtensions.ValueOrNull(ProbePin?) : Int32? + static op_LessThan(ProbePin, ProbePin) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbePin, ProbePin) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbePinExtensions.GetValue(ProbePin) : Int32 [IValueObject.Value] + extension static ProbePinExtensions.ValueOrNull(ProbePin?) : Int32? [IValueObject.Value] ProbePriority Label : String Match(Action, Action, Action) : Void - Match(Func, Func, Func) : TResult - Name : String - QualifiedName : String + Match(Func, Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] Rank : Int32 - ToString() : String + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested ProbePriorityJsonConverter : JsonConverter - nested ProbePriorityTypeConverter : TypeConverter - static All : IReadOnlyList + nested ProbePriorityJsonConverter : JsonConverter [IClosedSet.ProbePriorityJsonConverter] + nested ProbePriorityTypeConverter : TypeConverter [IClosedSet.ProbePriorityTypeConverter] + static All : IReadOnlyList [IClosedSet.All] static Parse(Int32) : ProbePriority - static Parse(String) : ProbePriority - static Parse(String, Boolean) : ProbePriority - static TryParse(String, Boolean, out ProbePriority) : Boolean - static TryParse(String, out ProbePriority) : Boolean + static Parse(String) : ProbePriority [IClosedSet.Parse] + static Parse(String, Boolean) : ProbePriority [IClosedSet.Parse] + static TryParse(String, Boolean, out ProbePriority) : Boolean [IClosedSet.TryParse] + static TryParse(String, out ProbePriority) : Boolean [IClosedSet.TryParse] ProbeRatio - CompareTo(Object) : Int32 - CompareTo(ProbeRatio) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeRatio) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeRatio) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Double + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Double [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1254,36 +1254,36 @@ ProbeRatio implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeRatioJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeRatioTypeConverter : TypeConverter + nested ProbeRatioJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeRatioJsonConverter] + nested ProbeRatioTypeConverter : TypeConverter [IValue.ProbeRatioTypeConverter] new() - static From(Double) : ProbeRatio - static MaxValue : ProbeRatio - static MinValue : ProbeRatio - static Parse(ReadOnlySpan, IFormatProvider) : ProbeRatio - static Parse(ReadOnlySpan, IFormatProvider) : ProbeRatio - static Parse(String, IFormatProvider) : ProbeRatio - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeRatio) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeRatio) : Boolean - static TryParse(String, IFormatProvider, out ProbeRatio) : Boolean + static From(Double) : ProbeRatio [IPlainValueObject.From] + static MaxValue : ProbeRatio [IMinMaxValue.MaxValue] + static MinValue : ProbeRatio [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeRatio [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeRatio [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeRatio [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeRatio) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeRatio) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeRatio) : Boolean [IParsable.TryParse] static op_Equality(ProbeRatio, ProbeRatio) : Boolean - static op_GreaterThan(ProbeRatio, ProbeRatio) : Boolean - static op_GreaterThanOrEqual(ProbeRatio, ProbeRatio) : Boolean + static op_GreaterThan(ProbeRatio, ProbeRatio) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeRatio, ProbeRatio) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeRatio, ProbeRatio) : Boolean - static op_LessThan(ProbeRatio, ProbeRatio) : Boolean - static op_LessThanOrEqual(ProbeRatio, ProbeRatio) : Boolean - extension static ProbeRatioExtensions.GetValue(ProbeRatio) : Double - extension static ProbeRatioExtensions.ValueOrNull(ProbeRatio?) : Double? + static op_LessThan(ProbeRatio, ProbeRatio) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeRatio, ProbeRatio) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeRatioExtensions.GetValue(ProbeRatio) : Double [IValueObject.Value] + extension static ProbeRatioExtensions.ValueOrNull(ProbeRatio?) : Double? [IValueObject.Value] ProbeReversedLabel $() : ProbeReversedLabel - CompareTo(Object) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] CompareTo(ProbeReversedLabel) : Int32 Equals(Object) : Boolean Equals(ProbeReversedLabel) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : String + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : String [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute HandWrittenOrderingAttribute @@ -1302,30 +1302,30 @@ ProbeReversedLabel implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeReversedLabelJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeReversedLabelTypeConverter : TypeConverter - static From(String) : ProbeReversedLabel - static Parse(ReadOnlySpan, IFormatProvider) : ProbeReversedLabel - static Parse(String, IFormatProvider) : ProbeReversedLabel - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeReversedLabel) : Boolean - static TryParse(String, IFormatProvider, out ProbeReversedLabel) : Boolean + nested ProbeReversedLabelJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeReversedLabelJsonConverter] + nested ProbeReversedLabelTypeConverter : TypeConverter [IValue.ProbeReversedLabelTypeConverter] + static From(String) : ProbeReversedLabel [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeReversedLabel [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeReversedLabel [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeReversedLabel) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeReversedLabel) : Boolean [IParsable.TryParse] static op_Equality(ProbeReversedLabel, ProbeReversedLabel) : Boolean - static op_GreaterThan(ProbeReversedLabel, ProbeReversedLabel) : Boolean - static op_GreaterThanOrEqual(ProbeReversedLabel, ProbeReversedLabel) : Boolean + static op_GreaterThan(ProbeReversedLabel, ProbeReversedLabel) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeReversedLabel, ProbeReversedLabel) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeReversedLabel, ProbeReversedLabel) : Boolean - static op_LessThan(ProbeReversedLabel, ProbeReversedLabel) : Boolean - static op_LessThanOrEqual(ProbeReversedLabel, ProbeReversedLabel) : Boolean - extension static ProbeReversedLabelExtensions.GetValue(ProbeReversedLabel) : String - extension static ProbeReversedLabelExtensions.ValueOrNull(ProbeReversedLabel) : String + static op_LessThan(ProbeReversedLabel, ProbeReversedLabel) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeReversedLabel, ProbeReversedLabel) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeReversedLabelExtensions.GetValue(ProbeReversedLabel) : String [IValueObject.Value] + extension static ProbeReversedLabelExtensions.ValueOrNull(ProbeReversedLabel) : String [IValueObject.Value] ProbeSecret $() : ProbeSecret - CompareTo(Object) : Int32 - CompareTo(ProbeSecret) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeSecret) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeSecret) : Boolean GetHashCode() : Int32 ToString() : String - Value : String + Value : String [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1342,46 +1342,46 @@ ProbeSecret implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeSecretJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeSecretTypeConverter : TypeConverter - static From(String) : ProbeSecret - static Parse(ReadOnlySpan, IFormatProvider) : ProbeSecret - static Parse(String, IFormatProvider) : ProbeSecret - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeSecret) : Boolean - static TryParse(String, IFormatProvider, out ProbeSecret) : Boolean + nested ProbeSecretJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeSecretJsonConverter] + nested ProbeSecretTypeConverter : TypeConverter [IValue.ProbeSecretTypeConverter] + static From(String) : ProbeSecret [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeSecret [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeSecret [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeSecret) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeSecret) : Boolean [IParsable.TryParse] static op_Equality(ProbeSecret, ProbeSecret) : Boolean - static op_GreaterThan(ProbeSecret, ProbeSecret) : Boolean - static op_GreaterThanOrEqual(ProbeSecret, ProbeSecret) : Boolean + static op_GreaterThan(ProbeSecret, ProbeSecret) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeSecret, ProbeSecret) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeSecret, ProbeSecret) : Boolean - static op_LessThan(ProbeSecret, ProbeSecret) : Boolean - static op_LessThanOrEqual(ProbeSecret, ProbeSecret) : Boolean - extension static ProbeSecretExtensions.GetValue(ProbeSecret) : String - extension static ProbeSecretExtensions.ValueOrNull(ProbeSecret) : String + static op_LessThan(ProbeSecret, ProbeSecret) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeSecret, ProbeSecret) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeSecretExtensions.GetValue(ProbeSecret) : String [IValueObject.Value] + extension static ProbeSecretExtensions.ValueOrNull(ProbeSecret) : String [IValueObject.Value] ProbeShipment.Status - Match(Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested StatusJsonConverter : JsonConverter - nested StatusTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : ProbeShipment.Status - static Parse(String, Boolean) : ProbeShipment.Status - static TryParse(String, Boolean, out ProbeShipment.Status) : Boolean - static TryParse(String, out ProbeShipment.Status) : Boolean + nested StatusJsonConverter : JsonConverter [IClosedSet.StatusJsonConverter] + nested StatusTypeConverter : TypeConverter [IClosedSet.StatusTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : ProbeShipment.Status [IClosedSet.Parse] + static Parse(String, Boolean) : ProbeShipment.Status [IClosedSet.Parse] + static TryParse(String, Boolean, out ProbeShipment.Status) : Boolean [IClosedSet.TryParse] + static TryParse(String, out ProbeShipment.Status) : Boolean [IClosedSet.TryParse] ProbeSku Equals(Object) : Boolean Equals(ProbeSku) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : ProbeSkuText + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ProbeSkuText [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1394,23 +1394,23 @@ ProbeSku implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeSkuJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeSkuTypeConverter : TypeConverter + nested ProbeSkuJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeSkuJsonConverter] + nested ProbeSkuTypeConverter : TypeConverter [IValue.ProbeSkuTypeConverter] new() - static From(ProbeSkuText) : ProbeSku - static Parse(String, IFormatProvider) : ProbeSku - static TryParse(String, IFormatProvider, out ProbeSku) : Boolean + static From(ProbeSkuText) : ProbeSku [IPlainValueObject.From] + static Parse(String, IFormatProvider) : ProbeSku [IParsable.Parse] + static TryParse(String, IFormatProvider, out ProbeSku) : Boolean [IParsable.TryParse] static op_Equality(ProbeSku, ProbeSku) : Boolean static op_Inequality(ProbeSku, ProbeSku) : Boolean - extension static ProbeSkuExtensions.GetValue(ProbeSku) : ProbeSkuText - extension static ProbeSkuExtensions.ValueOrNull(ProbeSku?) : ProbeSkuText + extension static ProbeSkuExtensions.GetValue(ProbeSku) : ProbeSkuText [IValueObject.Value] + extension static ProbeSkuExtensions.ValueOrNull(ProbeSku?) : ProbeSkuText [IValueObject.Value] ProbeSpan Equals(Object) : Boolean Equals(ProbeSpan) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : ProbeSpanText + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ProbeSpanText [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1423,83 +1423,83 @@ ProbeSpan implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeSpanJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeSpanTypeConverter : TypeConverter + nested ProbeSpanJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeSpanJsonConverter] + nested ProbeSpanTypeConverter : TypeConverter [IValue.ProbeSpanTypeConverter] new() - static From(ProbeSpanText) : ProbeSpan - static Parse(String, IFormatProvider) : ProbeSpan - static TryParse(String, IFormatProvider, out ProbeSpan) : Boolean + static From(ProbeSpanText) : ProbeSpan [IPlainValueObject.From] + static Parse(String, IFormatProvider) : ProbeSpan [IParsable.Parse] + static TryParse(String, IFormatProvider, out ProbeSpan) : Boolean [IParsable.TryParse] static op_Equality(ProbeSpan, ProbeSpan) : Boolean static op_Inequality(ProbeSpan, ProbeSpan) : Boolean - extension static ProbeSpanExtensions.GetValue(ProbeSpan) : ProbeSpanText - extension static ProbeSpanExtensions.ValueOrNull(ProbeSpan?) : ProbeSpanText + extension static ProbeSpanExtensions.GetValue(ProbeSpan) : ProbeSpanText [IValueObject.Value] + extension static ProbeSpanExtensions.ValueOrNull(ProbeSpan?) : ProbeSpanText [IValueObject.Value] ProbeSplit - Match(Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested ProbeSplitJsonConverter : JsonConverter - nested ProbeSplitTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : ProbeSplit - static Parse(String, Boolean) : ProbeSplit - static TryParse(String, Boolean, out ProbeSplit) : Boolean - static TryParse(String, out ProbeSplit) : Boolean + nested ProbeSplitJsonConverter : JsonConverter [IClosedSet.ProbeSplitJsonConverter] + nested ProbeSplitTypeConverter : TypeConverter [IClosedSet.ProbeSplitTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : ProbeSplit [IClosedSet.Parse] + static Parse(String, Boolean) : ProbeSplit [IClosedSet.Parse] + static TryParse(String, Boolean, out ProbeSplit) : Boolean [IClosedSet.TryParse] + static TryParse(String, out ProbeSplit) : Boolean [IClosedSet.TryParse] ProbeStatus - Match(Func, Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested ProbeStatusJsonConverter : JsonConverter - nested ProbeStatusTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : ProbeStatus - static Parse(String, Boolean) : ProbeStatus - static TryParse(String, Boolean, out ProbeStatus) : Boolean - static TryParse(String, out ProbeStatus) : Boolean + nested ProbeStatusJsonConverter : JsonConverter [IClosedSet.ProbeStatusJsonConverter] + nested ProbeStatusTypeConverter : TypeConverter [IClosedSet.ProbeStatusTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : ProbeStatus [IClosedSet.Parse] + static Parse(String, Boolean) : ProbeStatus [IClosedSet.Parse] + static TryParse(String, Boolean, out ProbeStatus) : Boolean [IClosedSet.TryParse] + static TryParse(String, out ProbeStatus) : Boolean [IClosedSet.TryParse] ProbeTier - Match(Func, Func) : TResult - Name : String + Match(Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] Perk : String - QualifiedName : String + QualifiedName : String [IClosedSet.QualifiedName] Rank : Int32 - ToString() : String + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested ProbeTierJsonConverter : JsonConverter - nested ProbeTierTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : ProbeTier - static Parse(String, Boolean) : ProbeTier - static TryParse(String, Boolean, out ProbeTier) : Boolean - static TryParse(String, out ProbeTier) : Boolean + nested ProbeTierJsonConverter : JsonConverter [IClosedSet.ProbeTierJsonConverter] + nested ProbeTierTypeConverter : TypeConverter [IClosedSet.ProbeTierTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : ProbeTier [IClosedSet.Parse] + static Parse(String, Boolean) : ProbeTier [IClosedSet.Parse] + static TryParse(String, Boolean, out ProbeTier) : Boolean [IClosedSet.TryParse] + static TryParse(String, out ProbeTier) : Boolean [IClosedSet.TryParse] ProbeTime - CompareTo(Object) : Int32 - CompareTo(ProbeTime) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeTime) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeTime) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : TimeOnly + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : TimeOnly [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1519,35 +1519,35 @@ ProbeTime implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeTimeJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeTimeTypeConverter : TypeConverter + nested ProbeTimeJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeTimeJsonConverter] + nested ProbeTimeTypeConverter : TypeConverter [IValue.ProbeTimeTypeConverter] new() - static From(TimeOnly) : ProbeTime - static MaxValue : ProbeTime - static MinValue : ProbeTime - static Parse(ReadOnlySpan, IFormatProvider) : ProbeTime - static Parse(String, IFormatProvider) : ProbeTime - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeTime) : Boolean - static TryParse(String, IFormatProvider, out ProbeTime) : Boolean + static From(TimeOnly) : ProbeTime [IPlainValueObject.From] + static MaxValue : ProbeTime [IMinMaxValue.MaxValue] + static MinValue : ProbeTime [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeTime [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeTime [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeTime) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeTime) : Boolean [IParsable.TryParse] static op_Equality(ProbeTime, ProbeTime) : Boolean - static op_GreaterThan(ProbeTime, ProbeTime) : Boolean - static op_GreaterThanOrEqual(ProbeTime, ProbeTime) : Boolean + static op_GreaterThan(ProbeTime, ProbeTime) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeTime, ProbeTime) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeTime, ProbeTime) : Boolean - static op_LessThan(ProbeTime, ProbeTime) : Boolean - static op_LessThanOrEqual(ProbeTime, ProbeTime) : Boolean - extension static ProbeTimeExtensions.GetValue(ProbeTime) : TimeOnly - extension static ProbeTimeExtensions.ValueOrNull(ProbeTime?) : TimeOnly? + static op_LessThan(ProbeTime, ProbeTime) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeTime, ProbeTime) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeTimeExtensions.GetValue(ProbeTime) : TimeOnly [IValueObject.Value] + extension static ProbeTimeExtensions.ValueOrNull(ProbeTime?) : TimeOnly? [IValueObject.Value] ProbeTimestamp - CompareTo(Object) : Int32 - CompareTo(ProbeTimestamp) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeTimestamp) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeTimestamp) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : DateTime + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : DateTime [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1568,32 +1568,32 @@ ProbeTimestamp implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeTimestampJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeTimestampTypeConverter : TypeConverter + nested ProbeTimestampJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeTimestampJsonConverter] + nested ProbeTimestampTypeConverter : TypeConverter [IValue.ProbeTimestampTypeConverter] new() - static From(DateTime) : ProbeTimestamp - static MaxValue : ProbeTimestamp - static MinValue : ProbeTimestamp - static Parse(ReadOnlySpan, IFormatProvider) : ProbeTimestamp - static Parse(String, IFormatProvider) : ProbeTimestamp - static TryParse(ReadOnlySpan, IFormatProvider, out ProbeTimestamp) : Boolean - static TryParse(String, IFormatProvider, out ProbeTimestamp) : Boolean + static From(DateTime) : ProbeTimestamp [IPlainValueObject.From] + static MaxValue : ProbeTimestamp [IMinMaxValue.MaxValue] + static MinValue : ProbeTimestamp [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ProbeTimestamp [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ProbeTimestamp [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ProbeTimestamp) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ProbeTimestamp) : Boolean [IParsable.TryParse] static op_Equality(ProbeTimestamp, ProbeTimestamp) : Boolean - static op_GreaterThan(ProbeTimestamp, ProbeTimestamp) : Boolean - static op_GreaterThanOrEqual(ProbeTimestamp, ProbeTimestamp) : Boolean + static op_GreaterThan(ProbeTimestamp, ProbeTimestamp) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeTimestamp, ProbeTimestamp) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeTimestamp, ProbeTimestamp) : Boolean - static op_LessThan(ProbeTimestamp, ProbeTimestamp) : Boolean - static op_LessThanOrEqual(ProbeTimestamp, ProbeTimestamp) : Boolean - extension static ProbeTimestampExtensions.GetValue(ProbeTimestamp) : DateTime - extension static ProbeTimestampExtensions.ValueOrNull(ProbeTimestamp?) : DateTime? + static op_LessThan(ProbeTimestamp, ProbeTimestamp) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeTimestamp, ProbeTimestamp) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeTimestampExtensions.GetValue(ProbeTimestamp) : DateTime [IValueObject.Value] + extension static ProbeTimestampExtensions.ValueOrNull(ProbeTimestamp?) : DateTime? [IValueObject.Value] ProbeUri Equals(Object) : Boolean Equals(ProbeUri) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Uri + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Uri [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1607,26 +1607,26 @@ ProbeUri implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeUriJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeUriTypeConverter : TypeConverter + nested ProbeUriJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeUriJsonConverter] + nested ProbeUriTypeConverter : TypeConverter [IValue.ProbeUriTypeConverter] new() - static From(Uri) : ProbeUri - static Parse(String, IFormatProvider) : ProbeUri - static TryParse(String, IFormatProvider, out ProbeUri) : Boolean + static From(Uri) : ProbeUri [IPlainValueObject.From] + static Parse(String, IFormatProvider) : ProbeUri [IParsable.Parse] + static TryParse(String, IFormatProvider, out ProbeUri) : Boolean [IParsable.TryParse] static op_Equality(ProbeUri, ProbeUri) : Boolean static op_Inequality(ProbeUri, ProbeUri) : Boolean - extension static ProbeUriExtensions.GetValue(ProbeUri) : Uri - extension static ProbeUriExtensions.ValueOrNull(ProbeUri?) : Uri + extension static ProbeUriExtensions.GetValue(ProbeUri) : Uri [IValueObject.Value] + extension static ProbeUriExtensions.ValueOrNull(ProbeUri?) : Uri [IValueObject.Value] ProbeWeekday - CompareTo(Object) : Int32 - CompareTo(ProbeWeekday) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ProbeWeekday) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ProbeWeekday) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : DayOfWeek + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : DayOfWeek [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1644,34 +1644,34 @@ ProbeWeekday implements IValue implements IValueObject implements IValueObjectMaterializer - nested ProbeWeekdayJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ProbeWeekdayTypeConverter : TypeConverter + nested ProbeWeekdayJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ProbeWeekdayJsonConverter] + nested ProbeWeekdayTypeConverter : TypeConverter [IValue.ProbeWeekdayTypeConverter] new() - static From(DayOfWeek) : ProbeWeekday - static Parse(String, IFormatProvider) : ProbeWeekday - static TryParse(String, IFormatProvider, out ProbeWeekday) : Boolean + static From(DayOfWeek) : ProbeWeekday [IPlainValueObject.From] + static Parse(String, IFormatProvider) : ProbeWeekday [IParsable.Parse] + static TryParse(String, IFormatProvider, out ProbeWeekday) : Boolean [IParsable.TryParse] static op_Equality(ProbeWeekday, ProbeWeekday) : Boolean - static op_GreaterThan(ProbeWeekday, ProbeWeekday) : Boolean - static op_GreaterThanOrEqual(ProbeWeekday, ProbeWeekday) : Boolean + static op_GreaterThan(ProbeWeekday, ProbeWeekday) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ProbeWeekday, ProbeWeekday) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ProbeWeekday, ProbeWeekday) : Boolean - static op_LessThan(ProbeWeekday, ProbeWeekday) : Boolean - static op_LessThanOrEqual(ProbeWeekday, ProbeWeekday) : Boolean - extension static ProbeWeekdayExtensions.GetValue(ProbeWeekday) : DayOfWeek - extension static ProbeWeekdayExtensions.ValueOrNull(ProbeWeekday?) : DayOfWeek? + static op_LessThan(ProbeWeekday, ProbeWeekday) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ProbeWeekday, ProbeWeekday) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ProbeWeekdayExtensions.GetValue(ProbeWeekday) : DayOfWeek [IValueObject.Value] + extension static ProbeWeekdayExtensions.ValueOrNull(ProbeWeekday?) : DayOfWeek? [IValueObject.Value] # CodoMetis.TypeKit.Generators.Tests AddsThroughBaseInterface $() : AddsThroughBaseInterface - CompareTo(AddsThroughBaseInterface) : Int32 - CompareTo(Object) : Int32 + CompareTo(AddsThroughBaseInterface) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(AddsThroughBase) : Boolean Equals(AddsThroughBaseInterface) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1697,36 +1697,36 @@ AddsThroughBaseInterface implements IValue implements IValueObject implements IValueObjectMaterializer - nested AddsThroughBaseInterfaceJsonConverter : JsonConverter, IStoredJsonConverterSource - nested AddsThroughBaseInterfaceTypeConverter : TypeConverter - static From(Int32) : AddsThroughBaseInterface - static MaxValue : AddsThroughBaseInterface - static MinValue : AddsThroughBaseInterface - static Parse(ReadOnlySpan, IFormatProvider) : AddsThroughBaseInterface - static Parse(ReadOnlySpan, IFormatProvider) : AddsThroughBaseInterface - static Parse(String, IFormatProvider) : AddsThroughBaseInterface - static TryParse(ReadOnlySpan, IFormatProvider, out AddsThroughBaseInterface) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out AddsThroughBaseInterface) : Boolean - static TryParse(String, IFormatProvider, out AddsThroughBaseInterface) : Boolean + nested AddsThroughBaseInterfaceJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.AddsThroughBaseInterfaceJsonConverter] + nested AddsThroughBaseInterfaceTypeConverter : TypeConverter [IValue.AddsThroughBaseInterfaceTypeConverter] + static From(Int32) : AddsThroughBaseInterface [IPlainValueObject.From] + static MaxValue : AddsThroughBaseInterface [IMinMaxValue.MaxValue] + static MinValue : AddsThroughBaseInterface [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : AddsThroughBaseInterface [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : AddsThroughBaseInterface [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : AddsThroughBaseInterface [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out AddsThroughBaseInterface) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out AddsThroughBaseInterface) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out AddsThroughBaseInterface) : Boolean [IParsable.TryParse] static op_Equality(AddsThroughBaseInterface, AddsThroughBaseInterface) : Boolean - static op_GreaterThan(AddsThroughBaseInterface, AddsThroughBaseInterface) : Boolean - static op_GreaterThanOrEqual(AddsThroughBaseInterface, AddsThroughBaseInterface) : Boolean + static op_GreaterThan(AddsThroughBaseInterface, AddsThroughBaseInterface) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(AddsThroughBaseInterface, AddsThroughBaseInterface) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(AddsThroughBaseInterface, AddsThroughBaseInterface) : Boolean - static op_LessThan(AddsThroughBaseInterface, AddsThroughBaseInterface) : Boolean - static op_LessThanOrEqual(AddsThroughBaseInterface, AddsThroughBaseInterface) : Boolean - extension static AddsThroughBaseInterfaceExtensions.GetValue(AddsThroughBaseInterface) : Int32 - extension static AddsThroughBaseInterfaceExtensions.ValueOrNull(AddsThroughBaseInterface) : Int32? + static op_LessThan(AddsThroughBaseInterface, AddsThroughBaseInterface) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(AddsThroughBaseInterface, AddsThroughBaseInterface) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static AddsThroughBaseInterfaceExtensions.GetValue(AddsThroughBaseInterface) : Int32 [IValueObject.Value] + extension static AddsThroughBaseInterfaceExtensions.ValueOrNull(AddsThroughBaseInterface) : Int32? [IValueObject.Value] AddsThroughInheritedInterface - CompareTo(AddsThroughInheritedInterface) : Int32 - CompareTo(Object) : Int32 + CompareTo(AddsThroughInheritedInterface) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(AddsThroughInheritedInterface) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1751,37 +1751,37 @@ AddsThroughInheritedInterface implements IValue implements IValueObject implements IValueObjectMaterializer - nested AddsThroughInheritedInterfaceJsonConverter : JsonConverter, IStoredJsonConverterSource - nested AddsThroughInheritedInterfaceTypeConverter : TypeConverter + nested AddsThroughInheritedInterfaceJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.AddsThroughInheritedInterfaceJsonConverter] + nested AddsThroughInheritedInterfaceTypeConverter : TypeConverter [IValue.AddsThroughInheritedInterfaceTypeConverter] new() - static From(Int32) : AddsThroughInheritedInterface - static MaxValue : AddsThroughInheritedInterface - static MinValue : AddsThroughInheritedInterface - static Parse(ReadOnlySpan, IFormatProvider) : AddsThroughInheritedInterface - static Parse(ReadOnlySpan, IFormatProvider) : AddsThroughInheritedInterface - static Parse(String, IFormatProvider) : AddsThroughInheritedInterface - static TryParse(ReadOnlySpan, IFormatProvider, out AddsThroughInheritedInterface) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out AddsThroughInheritedInterface) : Boolean - static TryParse(String, IFormatProvider, out AddsThroughInheritedInterface) : Boolean + static From(Int32) : AddsThroughInheritedInterface [IPlainValueObject.From] + static MaxValue : AddsThroughInheritedInterface [IMinMaxValue.MaxValue] + static MinValue : AddsThroughInheritedInterface [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : AddsThroughInheritedInterface [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : AddsThroughInheritedInterface [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : AddsThroughInheritedInterface [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out AddsThroughInheritedInterface) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out AddsThroughInheritedInterface) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out AddsThroughInheritedInterface) : Boolean [IParsable.TryParse] static op_Equality(AddsThroughInheritedInterface, AddsThroughInheritedInterface) : Boolean - static op_GreaterThan(AddsThroughInheritedInterface, AddsThroughInheritedInterface) : Boolean - static op_GreaterThanOrEqual(AddsThroughInheritedInterface, AddsThroughInheritedInterface) : Boolean + static op_GreaterThan(AddsThroughInheritedInterface, AddsThroughInheritedInterface) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(AddsThroughInheritedInterface, AddsThroughInheritedInterface) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(AddsThroughInheritedInterface, AddsThroughInheritedInterface) : Boolean - static op_LessThan(AddsThroughInheritedInterface, AddsThroughInheritedInterface) : Boolean - static op_LessThanOrEqual(AddsThroughInheritedInterface, AddsThroughInheritedInterface) : Boolean - extension static AddsThroughInheritedInterfaceExtensions.GetValue(AddsThroughInheritedInterface) : Int32 - extension static AddsThroughInheritedInterfaceExtensions.ValueOrNull(AddsThroughInheritedInterface?) : Int32? + static op_LessThan(AddsThroughInheritedInterface, AddsThroughInheritedInterface) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(AddsThroughInheritedInterface, AddsThroughInheritedInterface) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static AddsThroughInheritedInterfaceExtensions.GetValue(AddsThroughInheritedInterface) : Int32 [IValueObject.Value] + extension static AddsThroughInheritedInterfaceExtensions.ValueOrNull(AddsThroughInheritedInterface?) : Int32? [IValueObject.Value] AddsThroughInterface - CompareTo(AddsThroughInterface) : Int32 - CompareTo(Object) : Int32 + CompareTo(AddsThroughInterface) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(AddsThroughInterface) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1805,37 +1805,37 @@ AddsThroughInterface implements IValue implements IValueObject implements IValueObjectMaterializer - nested AddsThroughInterfaceJsonConverter : JsonConverter, IStoredJsonConverterSource - nested AddsThroughInterfaceTypeConverter : TypeConverter + nested AddsThroughInterfaceJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.AddsThroughInterfaceJsonConverter] + nested AddsThroughInterfaceTypeConverter : TypeConverter [IValue.AddsThroughInterfaceTypeConverter] new() - static From(Int32) : AddsThroughInterface - static MaxValue : AddsThroughInterface - static MinValue : AddsThroughInterface - static Parse(ReadOnlySpan, IFormatProvider) : AddsThroughInterface - static Parse(ReadOnlySpan, IFormatProvider) : AddsThroughInterface - static Parse(String, IFormatProvider) : AddsThroughInterface - static TryParse(ReadOnlySpan, IFormatProvider, out AddsThroughInterface) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out AddsThroughInterface) : Boolean - static TryParse(String, IFormatProvider, out AddsThroughInterface) : Boolean + static From(Int32) : AddsThroughInterface [IPlainValueObject.From] + static MaxValue : AddsThroughInterface [IMinMaxValue.MaxValue] + static MinValue : AddsThroughInterface [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : AddsThroughInterface [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : AddsThroughInterface [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : AddsThroughInterface [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out AddsThroughInterface) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out AddsThroughInterface) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out AddsThroughInterface) : Boolean [IParsable.TryParse] static op_Equality(AddsThroughInterface, AddsThroughInterface) : Boolean - static op_GreaterThan(AddsThroughInterface, AddsThroughInterface) : Boolean - static op_GreaterThanOrEqual(AddsThroughInterface, AddsThroughInterface) : Boolean + static op_GreaterThan(AddsThroughInterface, AddsThroughInterface) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(AddsThroughInterface, AddsThroughInterface) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(AddsThroughInterface, AddsThroughInterface) : Boolean - static op_LessThan(AddsThroughInterface, AddsThroughInterface) : Boolean - static op_LessThanOrEqual(AddsThroughInterface, AddsThroughInterface) : Boolean - extension static AddsThroughInterfaceExtensions.GetValue(AddsThroughInterface) : Int32 - extension static AddsThroughInterfaceExtensions.ValueOrNull(AddsThroughInterface?) : Int32? + static op_LessThan(AddsThroughInterface, AddsThroughInterface) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(AddsThroughInterface, AddsThroughInterface) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static AddsThroughInterfaceExtensions.GetValue(AddsThroughInterface) : Int32 [IValueObject.Value] + extension static AddsThroughInterfaceExtensions.ValueOrNull(AddsThroughInterface?) : Int32? [IValueObject.Value] BigIntegerAmount - CompareTo(BigIntegerAmount) : Int32 - CompareTo(Object) : Int32 + CompareTo(BigIntegerAmount) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(BigIntegerAmount) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : BigInteger + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : BigInteger [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1863,47 +1863,47 @@ BigIntegerAmount implements IValue implements IValueObject implements IValueObjectMaterializer - nested BigIntegerAmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested BigIntegerAmountTypeConverter : TypeConverter + nested BigIntegerAmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.BigIntegerAmountJsonConverter] + nested BigIntegerAmountTypeConverter : TypeConverter [IValue.BigIntegerAmountTypeConverter] new() - static From(BigInteger) : BigIntegerAmount - static Parse(ReadOnlySpan, IFormatProvider) : BigIntegerAmount - static Parse(ReadOnlySpan, IFormatProvider) : BigIntegerAmount - static Parse(String, IFormatProvider) : BigIntegerAmount - static TryParse(ReadOnlySpan, IFormatProvider, out BigIntegerAmount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out BigIntegerAmount) : Boolean - static TryParse(String, IFormatProvider, out BigIntegerAmount) : Boolean - static op_Addition(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount - static op_CheckedAddition(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount - static op_CheckedDivision(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount - static op_CheckedMultiply(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount - static op_CheckedSubtraction(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount - static op_CheckedUnaryNegation(BigIntegerAmount) : BigIntegerAmount - static op_Division(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount + static From(BigInteger) : BigIntegerAmount [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : BigIntegerAmount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : BigIntegerAmount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : BigIntegerAmount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out BigIntegerAmount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out BigIntegerAmount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out BigIntegerAmount) : Boolean [IParsable.TryParse] + static op_Addition(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount [IAdditionOperators.op_Addition] + static op_CheckedAddition(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(BigIntegerAmount) : BigIntegerAmount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount [IDivisionOperators.op_Division] static op_Equality(BigIntegerAmount, BigIntegerAmount) : Boolean - static op_GreaterThan(BigIntegerAmount, BigIntegerAmount) : Boolean - static op_GreaterThanOrEqual(BigIntegerAmount, BigIntegerAmount) : Boolean + static op_GreaterThan(BigIntegerAmount, BigIntegerAmount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(BigIntegerAmount, BigIntegerAmount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(BigIntegerAmount, BigIntegerAmount) : Boolean - static op_LessThan(BigIntegerAmount, BigIntegerAmount) : Boolean - static op_LessThanOrEqual(BigIntegerAmount, BigIntegerAmount) : Boolean - static op_Modulus(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount - static op_Multiply(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount - static op_Subtraction(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount - static op_UnaryNegation(BigIntegerAmount) : BigIntegerAmount - static op_UnaryPlus(BigIntegerAmount) : BigIntegerAmount - extension static BigIntegerAmountExtensions.GetValue(BigIntegerAmount) : BigInteger - extension static BigIntegerAmountExtensions.ValueOrNull(BigIntegerAmount?) : BigInteger? + static op_LessThan(BigIntegerAmount, BigIntegerAmount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(BigIntegerAmount, BigIntegerAmount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount [IModulusOperators.op_Modulus] + static op_Multiply(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount [IMultiplyOperators.op_Multiply] + static op_Subtraction(BigIntegerAmount, BigIntegerAmount) : BigIntegerAmount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(BigIntegerAmount) : BigIntegerAmount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(BigIntegerAmount) : BigIntegerAmount [IUnaryPlusOperators.op_UnaryPlus] + extension static BigIntegerAmountExtensions.GetValue(BigIntegerAmount) : BigInteger [IValueObject.Value] + extension static BigIntegerAmountExtensions.ValueOrNull(BigIntegerAmount?) : BigInteger? [IValueObject.Value] ByteAmount - CompareTo(ByteAmount) : Int32 - CompareTo(Object) : Int32 + CompareTo(ByteAmount) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(ByteAmount) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Byte + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Byte [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -1933,49 +1933,49 @@ ByteAmount implements IValue implements IValueObject implements IValueObjectMaterializer - nested ByteAmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ByteAmountTypeConverter : TypeConverter + nested ByteAmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ByteAmountJsonConverter] + nested ByteAmountTypeConverter : TypeConverter [IValue.ByteAmountTypeConverter] new() - static From(Byte) : ByteAmount - static MaxValue : ByteAmount - static MinValue : ByteAmount - static Parse(ReadOnlySpan, IFormatProvider) : ByteAmount - static Parse(ReadOnlySpan, IFormatProvider) : ByteAmount - static Parse(String, IFormatProvider) : ByteAmount - static TryParse(ReadOnlySpan, IFormatProvider, out ByteAmount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ByteAmount) : Boolean - static TryParse(String, IFormatProvider, out ByteAmount) : Boolean - static op_Addition(ByteAmount, ByteAmount) : ByteAmount - static op_CheckedAddition(ByteAmount, ByteAmount) : ByteAmount - static op_CheckedDivision(ByteAmount, ByteAmount) : ByteAmount - static op_CheckedMultiply(ByteAmount, ByteAmount) : ByteAmount - static op_CheckedSubtraction(ByteAmount, ByteAmount) : ByteAmount - static op_CheckedUnaryNegation(ByteAmount) : ByteAmount - static op_Division(ByteAmount, ByteAmount) : ByteAmount + static From(Byte) : ByteAmount [IPlainValueObject.From] + static MaxValue : ByteAmount [IMinMaxValue.MaxValue] + static MinValue : ByteAmount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ByteAmount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ByteAmount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ByteAmount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ByteAmount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ByteAmount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ByteAmount) : Boolean [IParsable.TryParse] + static op_Addition(ByteAmount, ByteAmount) : ByteAmount [IAdditionOperators.op_Addition] + static op_CheckedAddition(ByteAmount, ByteAmount) : ByteAmount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(ByteAmount, ByteAmount) : ByteAmount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(ByteAmount, ByteAmount) : ByteAmount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(ByteAmount, ByteAmount) : ByteAmount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(ByteAmount) : ByteAmount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(ByteAmount, ByteAmount) : ByteAmount [IDivisionOperators.op_Division] static op_Equality(ByteAmount, ByteAmount) : Boolean - static op_GreaterThan(ByteAmount, ByteAmount) : Boolean - static op_GreaterThanOrEqual(ByteAmount, ByteAmount) : Boolean + static op_GreaterThan(ByteAmount, ByteAmount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ByteAmount, ByteAmount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ByteAmount, ByteAmount) : Boolean - static op_LessThan(ByteAmount, ByteAmount) : Boolean - static op_LessThanOrEqual(ByteAmount, ByteAmount) : Boolean - static op_Modulus(ByteAmount, ByteAmount) : ByteAmount - static op_Multiply(ByteAmount, ByteAmount) : ByteAmount - static op_Subtraction(ByteAmount, ByteAmount) : ByteAmount - static op_UnaryNegation(ByteAmount) : ByteAmount - static op_UnaryPlus(ByteAmount) : ByteAmount - extension static ByteAmountExtensions.GetValue(ByteAmount) : Byte - extension static ByteAmountExtensions.ValueOrNull(ByteAmount?) : Byte? + static op_LessThan(ByteAmount, ByteAmount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ByteAmount, ByteAmount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(ByteAmount, ByteAmount) : ByteAmount [IModulusOperators.op_Modulus] + static op_Multiply(ByteAmount, ByteAmount) : ByteAmount [IMultiplyOperators.op_Multiply] + static op_Subtraction(ByteAmount, ByteAmount) : ByteAmount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(ByteAmount) : ByteAmount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(ByteAmount) : ByteAmount [IUnaryPlusOperators.op_UnaryPlus] + extension static ByteAmountExtensions.GetValue(ByteAmount) : Byte [IValueObject.Value] + extension static ByteAmountExtensions.ValueOrNull(ByteAmount?) : Byte? [IValueObject.Value] CharAmount - CompareTo(CharAmount) : Int32 - CompareTo(Object) : Int32 + CompareTo(CharAmount) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(CharAmount) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Char + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Char [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2005,50 +2005,50 @@ CharAmount implements IValue implements IValueObject implements IValueObjectMaterializer - nested CharAmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested CharAmountTypeConverter : TypeConverter + nested CharAmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.CharAmountJsonConverter] + nested CharAmountTypeConverter : TypeConverter [IValue.CharAmountTypeConverter] new() - static From(Char) : CharAmount - static MaxValue : CharAmount - static MinValue : CharAmount - static Parse(ReadOnlySpan, IFormatProvider) : CharAmount - static Parse(ReadOnlySpan, IFormatProvider) : CharAmount - static Parse(String, IFormatProvider) : CharAmount - static TryParse(ReadOnlySpan, IFormatProvider, out CharAmount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out CharAmount) : Boolean - static TryParse(String, IFormatProvider, out CharAmount) : Boolean - static op_Addition(CharAmount, CharAmount) : CharAmount - static op_CheckedAddition(CharAmount, CharAmount) : CharAmount - static op_CheckedDivision(CharAmount, CharAmount) : CharAmount - static op_CheckedMultiply(CharAmount, CharAmount) : CharAmount - static op_CheckedSubtraction(CharAmount, CharAmount) : CharAmount - static op_CheckedUnaryNegation(CharAmount) : CharAmount - static op_Division(CharAmount, CharAmount) : CharAmount + static From(Char) : CharAmount [IPlainValueObject.From] + static MaxValue : CharAmount [IMinMaxValue.MaxValue] + static MinValue : CharAmount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : CharAmount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : CharAmount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : CharAmount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out CharAmount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out CharAmount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out CharAmount) : Boolean [IParsable.TryParse] + static op_Addition(CharAmount, CharAmount) : CharAmount [IAdditionOperators.op_Addition] + static op_CheckedAddition(CharAmount, CharAmount) : CharAmount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(CharAmount, CharAmount) : CharAmount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(CharAmount, CharAmount) : CharAmount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(CharAmount, CharAmount) : CharAmount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(CharAmount) : CharAmount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(CharAmount, CharAmount) : CharAmount [IDivisionOperators.op_Division] static op_Equality(CharAmount, CharAmount) : Boolean - static op_GreaterThan(CharAmount, CharAmount) : Boolean - static op_GreaterThanOrEqual(CharAmount, CharAmount) : Boolean + static op_GreaterThan(CharAmount, CharAmount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(CharAmount, CharAmount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(CharAmount, CharAmount) : Boolean - static op_LessThan(CharAmount, CharAmount) : Boolean - static op_LessThanOrEqual(CharAmount, CharAmount) : Boolean - static op_Modulus(CharAmount, CharAmount) : CharAmount - static op_Multiply(CharAmount, CharAmount) : CharAmount - static op_Subtraction(CharAmount, CharAmount) : CharAmount - static op_UnaryNegation(CharAmount) : CharAmount - static op_UnaryPlus(CharAmount) : CharAmount - extension static CharAmountExtensions.GetValue(CharAmount) : Char - extension static CharAmountExtensions.ValueOrNull(CharAmount?) : Char? + static op_LessThan(CharAmount, CharAmount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(CharAmount, CharAmount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(CharAmount, CharAmount) : CharAmount [IModulusOperators.op_Modulus] + static op_Multiply(CharAmount, CharAmount) : CharAmount [IMultiplyOperators.op_Multiply] + static op_Subtraction(CharAmount, CharAmount) : CharAmount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(CharAmount) : CharAmount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(CharAmount) : CharAmount [IUnaryPlusOperators.op_UnaryPlus] + extension static CharAmountExtensions.GetValue(CharAmount) : Char [IValueObject.Value] + extension static CharAmountExtensions.ValueOrNull(CharAmount?) : Char? [IValueObject.Value] CompareToOverloadedByArity - CompareTo(CompareToOverloadedByArity) : Int32 - CompareTo(Object) : Int32 + CompareTo(CompareToOverloadedByArity) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] CompareTo(CompareToOverloadedByArity) : Int32 Equals(CompareToOverloadedByArity) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2070,38 +2070,38 @@ CompareToOverloadedByArity implements IValue implements IValueObject implements IValueObjectMaterializer - nested CompareToOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource - nested CompareToOverloadedByArityTypeConverter : TypeConverter + nested CompareToOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.CompareToOverloadedByArityJsonConverter] + nested CompareToOverloadedByArityTypeConverter : TypeConverter [IValue.CompareToOverloadedByArityTypeConverter] new() - static From(Int32) : CompareToOverloadedByArity - static MaxValue : CompareToOverloadedByArity - static MinValue : CompareToOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : CompareToOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : CompareToOverloadedByArity - static Parse(String, IFormatProvider) : CompareToOverloadedByArity - static TryParse(ReadOnlySpan, IFormatProvider, out CompareToOverloadedByArity) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out CompareToOverloadedByArity) : Boolean - static TryParse(String, IFormatProvider, out CompareToOverloadedByArity) : Boolean + static From(Int32) : CompareToOverloadedByArity [IPlainValueObject.From] + static MaxValue : CompareToOverloadedByArity [IMinMaxValue.MaxValue] + static MinValue : CompareToOverloadedByArity [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : CompareToOverloadedByArity [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : CompareToOverloadedByArity [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : CompareToOverloadedByArity [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out CompareToOverloadedByArity) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out CompareToOverloadedByArity) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out CompareToOverloadedByArity) : Boolean [IParsable.TryParse] static op_Equality(CompareToOverloadedByArity, CompareToOverloadedByArity) : Boolean - static op_GreaterThan(CompareToOverloadedByArity, CompareToOverloadedByArity) : Boolean - static op_GreaterThanOrEqual(CompareToOverloadedByArity, CompareToOverloadedByArity) : Boolean + static op_GreaterThan(CompareToOverloadedByArity, CompareToOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(CompareToOverloadedByArity, CompareToOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(CompareToOverloadedByArity, CompareToOverloadedByArity) : Boolean - static op_LessThan(CompareToOverloadedByArity, CompareToOverloadedByArity) : Boolean - static op_LessThanOrEqual(CompareToOverloadedByArity, CompareToOverloadedByArity) : Boolean - extension static CompareToOverloadedByArityExtensions.GetValue(CompareToOverloadedByArity) : Int32 - extension static CompareToOverloadedByArityExtensions.ValueOrNull(CompareToOverloadedByArity?) : Int32? + static op_LessThan(CompareToOverloadedByArity, CompareToOverloadedByArity) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(CompareToOverloadedByArity, CompareToOverloadedByArity) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static CompareToOverloadedByArityExtensions.GetValue(CompareToOverloadedByArity) : Int32 [IValueObject.Value] + extension static CompareToOverloadedByArityExtensions.ValueOrNull(CompareToOverloadedByArity?) : Int32? [IValueObject.Value] CompareToOverloadedByIn - CompareTo(CompareToOverloadedByIn) : Int32 - CompareTo(Object) : Int32 + CompareTo(CompareToOverloadedByIn) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] CompareTo(in CompareToOverloadedByIn) : Int32 Equals(CompareToOverloadedByIn) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2123,37 +2123,37 @@ CompareToOverloadedByIn implements IValue implements IValueObject implements IValueObjectMaterializer - nested CompareToOverloadedByInJsonConverter : JsonConverter, IStoredJsonConverterSource - nested CompareToOverloadedByInTypeConverter : TypeConverter + nested CompareToOverloadedByInJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.CompareToOverloadedByInJsonConverter] + nested CompareToOverloadedByInTypeConverter : TypeConverter [IValue.CompareToOverloadedByInTypeConverter] new() - static From(Int32) : CompareToOverloadedByIn - static MaxValue : CompareToOverloadedByIn - static MinValue : CompareToOverloadedByIn - static Parse(ReadOnlySpan, IFormatProvider) : CompareToOverloadedByIn - static Parse(ReadOnlySpan, IFormatProvider) : CompareToOverloadedByIn - static Parse(String, IFormatProvider) : CompareToOverloadedByIn - static TryParse(ReadOnlySpan, IFormatProvider, out CompareToOverloadedByIn) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out CompareToOverloadedByIn) : Boolean - static TryParse(String, IFormatProvider, out CompareToOverloadedByIn) : Boolean + static From(Int32) : CompareToOverloadedByIn [IPlainValueObject.From] + static MaxValue : CompareToOverloadedByIn [IMinMaxValue.MaxValue] + static MinValue : CompareToOverloadedByIn [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : CompareToOverloadedByIn [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : CompareToOverloadedByIn [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : CompareToOverloadedByIn [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out CompareToOverloadedByIn) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out CompareToOverloadedByIn) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out CompareToOverloadedByIn) : Boolean [IParsable.TryParse] static op_Equality(CompareToOverloadedByIn, CompareToOverloadedByIn) : Boolean - static op_GreaterThan(CompareToOverloadedByIn, CompareToOverloadedByIn) : Boolean - static op_GreaterThanOrEqual(CompareToOverloadedByIn, CompareToOverloadedByIn) : Boolean + static op_GreaterThan(CompareToOverloadedByIn, CompareToOverloadedByIn) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(CompareToOverloadedByIn, CompareToOverloadedByIn) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(CompareToOverloadedByIn, CompareToOverloadedByIn) : Boolean - static op_LessThan(CompareToOverloadedByIn, CompareToOverloadedByIn) : Boolean - static op_LessThanOrEqual(CompareToOverloadedByIn, CompareToOverloadedByIn) : Boolean - extension static CompareToOverloadedByInExtensions.GetValue(CompareToOverloadedByIn) : Int32 - extension static CompareToOverloadedByInExtensions.ValueOrNull(CompareToOverloadedByIn?) : Int32? + static op_LessThan(CompareToOverloadedByIn, CompareToOverloadedByIn) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(CompareToOverloadedByIn, CompareToOverloadedByIn) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static CompareToOverloadedByInExtensions.GetValue(CompareToOverloadedByIn) : Int32 [IValueObject.Value] + extension static CompareToOverloadedByInExtensions.ValueOrNull(CompareToOverloadedByIn?) : Int32? [IValueObject.Value] DecimalAmount - CompareTo(DecimalAmount) : Int32 - CompareTo(Object) : Int32 + CompareTo(DecimalAmount) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(DecimalAmount) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Decimal + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Decimal [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2183,47 +2183,47 @@ DecimalAmount implements IValue implements IValueObject implements IValueObjectMaterializer - nested DecimalAmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested DecimalAmountTypeConverter : TypeConverter + nested DecimalAmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.DecimalAmountJsonConverter] + nested DecimalAmountTypeConverter : TypeConverter [IValue.DecimalAmountTypeConverter] new() - static From(Decimal) : DecimalAmount - static MaxValue : DecimalAmount - static MinValue : DecimalAmount - static Parse(ReadOnlySpan, IFormatProvider) : DecimalAmount - static Parse(ReadOnlySpan, IFormatProvider) : DecimalAmount - static Parse(String, IFormatProvider) : DecimalAmount - static TryParse(ReadOnlySpan, IFormatProvider, out DecimalAmount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out DecimalAmount) : Boolean - static TryParse(String, IFormatProvider, out DecimalAmount) : Boolean - static op_Addition(DecimalAmount, DecimalAmount) : DecimalAmount - static op_CheckedAddition(DecimalAmount, DecimalAmount) : DecimalAmount - static op_CheckedDivision(DecimalAmount, DecimalAmount) : DecimalAmount - static op_CheckedMultiply(DecimalAmount, DecimalAmount) : DecimalAmount - static op_CheckedSubtraction(DecimalAmount, DecimalAmount) : DecimalAmount - static op_CheckedUnaryNegation(DecimalAmount) : DecimalAmount - static op_Division(DecimalAmount, DecimalAmount) : DecimalAmount + static From(Decimal) : DecimalAmount [IPlainValueObject.From] + static MaxValue : DecimalAmount [IMinMaxValue.MaxValue] + static MinValue : DecimalAmount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : DecimalAmount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : DecimalAmount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : DecimalAmount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out DecimalAmount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out DecimalAmount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out DecimalAmount) : Boolean [IParsable.TryParse] + static op_Addition(DecimalAmount, DecimalAmount) : DecimalAmount [IAdditionOperators.op_Addition] + static op_CheckedAddition(DecimalAmount, DecimalAmount) : DecimalAmount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(DecimalAmount, DecimalAmount) : DecimalAmount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(DecimalAmount, DecimalAmount) : DecimalAmount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(DecimalAmount, DecimalAmount) : DecimalAmount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(DecimalAmount) : DecimalAmount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(DecimalAmount, DecimalAmount) : DecimalAmount [IDivisionOperators.op_Division] static op_Equality(DecimalAmount, DecimalAmount) : Boolean - static op_GreaterThan(DecimalAmount, DecimalAmount) : Boolean - static op_GreaterThanOrEqual(DecimalAmount, DecimalAmount) : Boolean + static op_GreaterThan(DecimalAmount, DecimalAmount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(DecimalAmount, DecimalAmount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(DecimalAmount, DecimalAmount) : Boolean - static op_LessThan(DecimalAmount, DecimalAmount) : Boolean - static op_LessThanOrEqual(DecimalAmount, DecimalAmount) : Boolean - static op_Modulus(DecimalAmount, DecimalAmount) : DecimalAmount - static op_Multiply(DecimalAmount, DecimalAmount) : DecimalAmount - static op_Subtraction(DecimalAmount, DecimalAmount) : DecimalAmount - static op_UnaryNegation(DecimalAmount) : DecimalAmount - static op_UnaryPlus(DecimalAmount) : DecimalAmount - extension static DecimalAmountExtensions.GetValue(DecimalAmount) : Decimal - extension static DecimalAmountExtensions.ValueOrNull(DecimalAmount?) : Decimal? + static op_LessThan(DecimalAmount, DecimalAmount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(DecimalAmount, DecimalAmount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(DecimalAmount, DecimalAmount) : DecimalAmount [IModulusOperators.op_Modulus] + static op_Multiply(DecimalAmount, DecimalAmount) : DecimalAmount [IMultiplyOperators.op_Multiply] + static op_Subtraction(DecimalAmount, DecimalAmount) : DecimalAmount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(DecimalAmount) : DecimalAmount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(DecimalAmount) : DecimalAmount [IUnaryPlusOperators.op_UnaryPlus] + extension static DecimalAmountExtensions.GetValue(DecimalAmount) : Decimal [IValueObject.Value] + extension static DecimalAmountExtensions.ValueOrNull(DecimalAmount?) : Decimal? [IValueObject.Value] DefaultedAddress Equals(DefaultedAddress) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : IPAddress + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : IPAddress [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2240,31 +2240,31 @@ DefaultedAddress implements IValue implements IValueObject implements IValueObjectMaterializer - nested DefaultedAddressJsonConverter : JsonConverter, IStoredJsonConverterSource - nested DefaultedAddressTypeConverter : TypeConverter + nested DefaultedAddressJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.DefaultedAddressJsonConverter] + nested DefaultedAddressTypeConverter : TypeConverter [IValue.DefaultedAddressTypeConverter] new() - static From(IPAddress) : DefaultedAddress - static Parse(ReadOnlySpan, IFormatProvider) : DefaultedAddress - static Parse(ReadOnlySpan, IFormatProvider) : DefaultedAddress - static Parse(String, IFormatProvider) : DefaultedAddress - static TryParse(ReadOnlySpan, IFormatProvider, out DefaultedAddress) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out DefaultedAddress) : Boolean - static TryParse(String, IFormatProvider, out DefaultedAddress) : Boolean + static From(IPAddress) : DefaultedAddress [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : DefaultedAddress [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : DefaultedAddress [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : DefaultedAddress [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out DefaultedAddress) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out DefaultedAddress) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out DefaultedAddress) : Boolean [IParsable.TryParse] static op_Equality(DefaultedAddress, DefaultedAddress) : Boolean static op_Inequality(DefaultedAddress, DefaultedAddress) : Boolean - extension static DefaultedAddressExtensions.GetValue(DefaultedAddress) : IPAddress - extension static DefaultedAddressExtensions.ValueOrNull(DefaultedAddress?) : IPAddress + extension static DefaultedAddressExtensions.GetValue(DefaultedAddress) : IPAddress [IValueObject.Value] + extension static DefaultedAddressExtensions.ValueOrNull(DefaultedAddress?) : IPAddress [IValueObject.Value] DefaultedVersion - CompareTo(DefaultedVersion) : Int32 - CompareTo(Object) : Int32 + CompareTo(DefaultedVersion) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(DefaultedVersion) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Version + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Version [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2283,51 +2283,51 @@ DefaultedVersion implements IValue implements IValueObject implements IValueObjectMaterializer - nested DefaultedVersionJsonConverter : JsonConverter, IStoredJsonConverterSource - nested DefaultedVersionTypeConverter : TypeConverter + nested DefaultedVersionJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.DefaultedVersionJsonConverter] + nested DefaultedVersionTypeConverter : TypeConverter [IValue.DefaultedVersionTypeConverter] new() - static From(Version) : DefaultedVersion - static Parse(ReadOnlySpan, IFormatProvider) : DefaultedVersion - static Parse(String, IFormatProvider) : DefaultedVersion - static TryParse(ReadOnlySpan, IFormatProvider, out DefaultedVersion) : Boolean - static TryParse(String, IFormatProvider, out DefaultedVersion) : Boolean + static From(Version) : DefaultedVersion [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : DefaultedVersion [IUtf8SpanParsable.Parse] + static Parse(String, IFormatProvider) : DefaultedVersion [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out DefaultedVersion) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(String, IFormatProvider, out DefaultedVersion) : Boolean [IParsable.TryParse] static op_Equality(DefaultedVersion, DefaultedVersion) : Boolean - static op_GreaterThan(DefaultedVersion, DefaultedVersion) : Boolean - static op_GreaterThanOrEqual(DefaultedVersion, DefaultedVersion) : Boolean + static op_GreaterThan(DefaultedVersion, DefaultedVersion) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(DefaultedVersion, DefaultedVersion) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(DefaultedVersion, DefaultedVersion) : Boolean - static op_LessThan(DefaultedVersion, DefaultedVersion) : Boolean - static op_LessThanOrEqual(DefaultedVersion, DefaultedVersion) : Boolean - extension static DefaultedVersionExtensions.GetValue(DefaultedVersion) : Version - extension static DefaultedVersionExtensions.ValueOrNull(DefaultedVersion?) : Version + static op_LessThan(DefaultedVersion, DefaultedVersion) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(DefaultedVersion, DefaultedVersion) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static DefaultedVersionExtensions.GetValue(DefaultedVersion) : Version [IValueObject.Value] + extension static DefaultedVersionExtensions.ValueOrNull(DefaultedVersion?) : Version [IValueObject.Value] DocumentKind - Match(Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested DocumentKindJsonConverter : JsonConverter - nested DocumentKindTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : DocumentKind - static Parse(String, Boolean) : DocumentKind - static TryParse(String, Boolean, out DocumentKind) : Boolean - static TryParse(String, out DocumentKind) : Boolean + nested DocumentKindJsonConverter : JsonConverter [IClosedSet.DocumentKindJsonConverter] + nested DocumentKindTypeConverter : TypeConverter [IClosedSet.DocumentKindTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : DocumentKind [IClosedSet.Parse] + static Parse(String, Boolean) : DocumentKind [IClosedSet.Parse] + static TryParse(String, Boolean, out DocumentKind) : Boolean [IClosedSet.TryParse] + static TryParse(String, out DocumentKind) : Boolean [IClosedSet.TryParse] DoubleAmount - CompareTo(DoubleAmount) : Int32 - CompareTo(Object) : Int32 + CompareTo(DoubleAmount) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(DoubleAmount) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Double + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Double [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2357,50 +2357,50 @@ DoubleAmount implements IValue implements IValueObject implements IValueObjectMaterializer - nested DoubleAmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested DoubleAmountTypeConverter : TypeConverter + nested DoubleAmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.DoubleAmountJsonConverter] + nested DoubleAmountTypeConverter : TypeConverter [IValue.DoubleAmountTypeConverter] new() - static From(Double) : DoubleAmount - static MaxValue : DoubleAmount - static MinValue : DoubleAmount - static Parse(ReadOnlySpan, IFormatProvider) : DoubleAmount - static Parse(ReadOnlySpan, IFormatProvider) : DoubleAmount - static Parse(String, IFormatProvider) : DoubleAmount - static TryParse(ReadOnlySpan, IFormatProvider, out DoubleAmount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out DoubleAmount) : Boolean - static TryParse(String, IFormatProvider, out DoubleAmount) : Boolean - static op_Addition(DoubleAmount, DoubleAmount) : DoubleAmount - static op_CheckedAddition(DoubleAmount, DoubleAmount) : DoubleAmount - static op_CheckedDivision(DoubleAmount, DoubleAmount) : DoubleAmount - static op_CheckedMultiply(DoubleAmount, DoubleAmount) : DoubleAmount - static op_CheckedSubtraction(DoubleAmount, DoubleAmount) : DoubleAmount - static op_CheckedUnaryNegation(DoubleAmount) : DoubleAmount - static op_Division(DoubleAmount, DoubleAmount) : DoubleAmount + static From(Double) : DoubleAmount [IPlainValueObject.From] + static MaxValue : DoubleAmount [IMinMaxValue.MaxValue] + static MinValue : DoubleAmount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : DoubleAmount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : DoubleAmount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : DoubleAmount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out DoubleAmount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out DoubleAmount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out DoubleAmount) : Boolean [IParsable.TryParse] + static op_Addition(DoubleAmount, DoubleAmount) : DoubleAmount [IAdditionOperators.op_Addition] + static op_CheckedAddition(DoubleAmount, DoubleAmount) : DoubleAmount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(DoubleAmount, DoubleAmount) : DoubleAmount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(DoubleAmount, DoubleAmount) : DoubleAmount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(DoubleAmount, DoubleAmount) : DoubleAmount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(DoubleAmount) : DoubleAmount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(DoubleAmount, DoubleAmount) : DoubleAmount [IDivisionOperators.op_Division] static op_Equality(DoubleAmount, DoubleAmount) : Boolean - static op_GreaterThan(DoubleAmount, DoubleAmount) : Boolean - static op_GreaterThanOrEqual(DoubleAmount, DoubleAmount) : Boolean + static op_GreaterThan(DoubleAmount, DoubleAmount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(DoubleAmount, DoubleAmount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(DoubleAmount, DoubleAmount) : Boolean - static op_LessThan(DoubleAmount, DoubleAmount) : Boolean - static op_LessThanOrEqual(DoubleAmount, DoubleAmount) : Boolean - static op_Modulus(DoubleAmount, DoubleAmount) : DoubleAmount - static op_Multiply(DoubleAmount, DoubleAmount) : DoubleAmount - static op_Subtraction(DoubleAmount, DoubleAmount) : DoubleAmount - static op_UnaryNegation(DoubleAmount) : DoubleAmount - static op_UnaryPlus(DoubleAmount) : DoubleAmount - extension static DoubleAmountExtensions.GetValue(DoubleAmount) : Double - extension static DoubleAmountExtensions.ValueOrNull(DoubleAmount?) : Double? + static op_LessThan(DoubleAmount, DoubleAmount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(DoubleAmount, DoubleAmount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(DoubleAmount, DoubleAmount) : DoubleAmount [IModulusOperators.op_Modulus] + static op_Multiply(DoubleAmount, DoubleAmount) : DoubleAmount [IMultiplyOperators.op_Multiply] + static op_Subtraction(DoubleAmount, DoubleAmount) : DoubleAmount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(DoubleAmount) : DoubleAmount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(DoubleAmount) : DoubleAmount [IUnaryPlusOperators.op_UnaryPlus] + extension static DoubleAmountExtensions.GetValue(DoubleAmount) : Double [IValueObject.Value] + extension static DoubleAmountExtensions.ValueOrNull(DoubleAmount?) : Double? [IValueObject.Value] DoubleAmountClass $() : DoubleAmountClass - CompareTo(DoubleAmountClass) : Int32 - CompareTo(Object) : Int32 + CompareTo(DoubleAmountClass) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(DoubleAmountClass) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Double + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Double [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2430,194 +2430,194 @@ DoubleAmountClass implements IValue implements IValueObject implements IValueObjectMaterializer - nested DoubleAmountClassJsonConverter : JsonConverter, IStoredJsonConverterSource - nested DoubleAmountClassTypeConverter : TypeConverter - static From(Double) : DoubleAmountClass - static MaxValue : DoubleAmountClass - static MinValue : DoubleAmountClass - static Parse(ReadOnlySpan, IFormatProvider) : DoubleAmountClass - static Parse(ReadOnlySpan, IFormatProvider) : DoubleAmountClass - static Parse(String, IFormatProvider) : DoubleAmountClass - static TryParse(ReadOnlySpan, IFormatProvider, out DoubleAmountClass) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out DoubleAmountClass) : Boolean - static TryParse(String, IFormatProvider, out DoubleAmountClass) : Boolean - static op_Addition(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass - static op_CheckedAddition(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass - static op_CheckedDivision(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass - static op_CheckedMultiply(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass - static op_CheckedSubtraction(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass - static op_CheckedUnaryNegation(DoubleAmountClass) : DoubleAmountClass - static op_Division(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass + nested DoubleAmountClassJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.DoubleAmountClassJsonConverter] + nested DoubleAmountClassTypeConverter : TypeConverter [IValue.DoubleAmountClassTypeConverter] + static From(Double) : DoubleAmountClass [IPlainValueObject.From] + static MaxValue : DoubleAmountClass [IMinMaxValue.MaxValue] + static MinValue : DoubleAmountClass [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : DoubleAmountClass [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : DoubleAmountClass [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : DoubleAmountClass [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out DoubleAmountClass) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out DoubleAmountClass) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out DoubleAmountClass) : Boolean [IParsable.TryParse] + static op_Addition(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass [IAdditionOperators.op_Addition] + static op_CheckedAddition(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(DoubleAmountClass) : DoubleAmountClass [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass [IDivisionOperators.op_Division] static op_Equality(DoubleAmountClass, DoubleAmountClass) : Boolean - static op_GreaterThan(DoubleAmountClass, DoubleAmountClass) : Boolean - static op_GreaterThanOrEqual(DoubleAmountClass, DoubleAmountClass) : Boolean + static op_GreaterThan(DoubleAmountClass, DoubleAmountClass) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(DoubleAmountClass, DoubleAmountClass) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(DoubleAmountClass, DoubleAmountClass) : Boolean - static op_LessThan(DoubleAmountClass, DoubleAmountClass) : Boolean - static op_LessThanOrEqual(DoubleAmountClass, DoubleAmountClass) : Boolean - static op_Modulus(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass - static op_Multiply(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass - static op_Subtraction(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass - static op_UnaryNegation(DoubleAmountClass) : DoubleAmountClass - static op_UnaryPlus(DoubleAmountClass) : DoubleAmountClass - extension static DoubleAmountClassExtensions.GetValue(DoubleAmountClass) : Double - extension static DoubleAmountClassExtensions.ValueOrNull(DoubleAmountClass) : Double? + static op_LessThan(DoubleAmountClass, DoubleAmountClass) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(DoubleAmountClass, DoubleAmountClass) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass [IModulusOperators.op_Modulus] + static op_Multiply(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass [IMultiplyOperators.op_Multiply] + static op_Subtraction(DoubleAmountClass, DoubleAmountClass) : DoubleAmountClass [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(DoubleAmountClass) : DoubleAmountClass [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(DoubleAmountClass) : DoubleAmountClass [IUnaryPlusOperators.op_UnaryPlus] + extension static DoubleAmountClassExtensions.GetValue(DoubleAmountClass) : Double [IValueObject.Value] + extension static DoubleAmountClassExtensions.ValueOrNull(DoubleAmountClass) : Double? [IValueObject.Value] EarlyAllStatus - Match(Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested EarlyAllStatusJsonConverter : JsonConverter - nested EarlyAllStatusTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : EarlyAllStatus - static Parse(String, Boolean) : EarlyAllStatus - static TryParse(String, Boolean, out EarlyAllStatus) : Boolean - static TryParse(String, out EarlyAllStatus) : Boolean + nested EarlyAllStatusJsonConverter : JsonConverter [IClosedSet.EarlyAllStatusJsonConverter] + nested EarlyAllStatusTypeConverter : TypeConverter [IClosedSet.EarlyAllStatusTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : EarlyAllStatus [IClosedSet.Parse] + static Parse(String, Boolean) : EarlyAllStatus [IClosedSet.Parse] + static TryParse(String, Boolean, out EarlyAllStatus) : Boolean [IClosedSet.TryParse] + static TryParse(String, out EarlyAllStatus) : Boolean [IClosedSet.TryParse] EarlyIgnoreCaseParseStatus - Match(Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested EarlyIgnoreCaseParseStatusJsonConverter : JsonConverter - nested EarlyIgnoreCaseParseStatusTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : EarlyIgnoreCaseParseStatus - static Parse(String, Boolean) : EarlyIgnoreCaseParseStatus - static TryParse(String, Boolean, out EarlyIgnoreCaseParseStatus) : Boolean - static TryParse(String, out EarlyIgnoreCaseParseStatus) : Boolean + nested EarlyIgnoreCaseParseStatusJsonConverter : JsonConverter [IClosedSet.EarlyIgnoreCaseParseStatusJsonConverter] + nested EarlyIgnoreCaseParseStatusTypeConverter : TypeConverter [IClosedSet.EarlyIgnoreCaseParseStatusTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : EarlyIgnoreCaseParseStatus [IClosedSet.Parse] + static Parse(String, Boolean) : EarlyIgnoreCaseParseStatus [IClosedSet.Parse] + static TryParse(String, Boolean, out EarlyIgnoreCaseParseStatus) : Boolean [IClosedSet.TryParse] + static TryParse(String, out EarlyIgnoreCaseParseStatus) : Boolean [IClosedSet.TryParse] EarlyIgnoreCaseTryParseStatus - Match(Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested EarlyIgnoreCaseTryParseStatusJsonConverter : JsonConverter - nested EarlyIgnoreCaseTryParseStatusTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : EarlyIgnoreCaseTryParseStatus - static Parse(String, Boolean) : EarlyIgnoreCaseTryParseStatus - static TryParse(String, Boolean, out EarlyIgnoreCaseTryParseStatus) : Boolean - static TryParse(String, out EarlyIgnoreCaseTryParseStatus) : Boolean + nested EarlyIgnoreCaseTryParseStatusJsonConverter : JsonConverter [IClosedSet.EarlyIgnoreCaseTryParseStatusJsonConverter] + nested EarlyIgnoreCaseTryParseStatusTypeConverter : TypeConverter [IClosedSet.EarlyIgnoreCaseTryParseStatusTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : EarlyIgnoreCaseTryParseStatus [IClosedSet.Parse] + static Parse(String, Boolean) : EarlyIgnoreCaseTryParseStatus [IClosedSet.Parse] + static TryParse(String, Boolean, out EarlyIgnoreCaseTryParseStatus) : Boolean [IClosedSet.TryParse] + static TryParse(String, out EarlyIgnoreCaseTryParseStatus) : Boolean [IClosedSet.TryParse] EarlyJsonKeyStatus - Match(Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested EarlyJsonKeyStatusJsonConverter : JsonConverter - nested EarlyJsonKeyStatusTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : EarlyJsonKeyStatus - static Parse(String, Boolean) : EarlyJsonKeyStatus - static TryParse(String, Boolean, out EarlyJsonKeyStatus) : Boolean - static TryParse(String, out EarlyJsonKeyStatus) : Boolean + nested EarlyJsonKeyStatusJsonConverter : JsonConverter [IClosedSet.EarlyJsonKeyStatusJsonConverter] + nested EarlyJsonKeyStatusTypeConverter : TypeConverter [IClosedSet.EarlyJsonKeyStatusTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : EarlyJsonKeyStatus [IClosedSet.Parse] + static Parse(String, Boolean) : EarlyJsonKeyStatus [IClosedSet.Parse] + static TryParse(String, Boolean, out EarlyJsonKeyStatus) : Boolean [IClosedSet.TryParse] + static TryParse(String, out EarlyJsonKeyStatus) : Boolean [IClosedSet.TryParse] EarlyJsonStatus - Match(Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested EarlyJsonStatusJsonConverter : JsonConverter - nested EarlyJsonStatusTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : EarlyJsonStatus - static Parse(String, Boolean) : EarlyJsonStatus - static TryParse(String, Boolean, out EarlyJsonStatus) : Boolean - static TryParse(String, out EarlyJsonStatus) : Boolean + nested EarlyJsonStatusJsonConverter : JsonConverter [IClosedSet.EarlyJsonStatusJsonConverter] + nested EarlyJsonStatusTypeConverter : TypeConverter [IClosedSet.EarlyJsonStatusTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : EarlyJsonStatus [IClosedSet.Parse] + static Parse(String, Boolean) : EarlyJsonStatus [IClosedSet.Parse] + static TryParse(String, Boolean, out EarlyJsonStatus) : Boolean [IClosedSet.TryParse] + static TryParse(String, out EarlyJsonStatus) : Boolean [IClosedSet.TryParse] EarlyParsableStatus - Match(Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested EarlyParsableStatusJsonConverter : JsonConverter - nested EarlyParsableStatusTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : EarlyParsableStatus - static Parse(String, Boolean) : EarlyParsableStatus - static TryParse(String, Boolean, out EarlyParsableStatus) : Boolean - static TryParse(String, out EarlyParsableStatus) : Boolean + nested EarlyParsableStatusJsonConverter : JsonConverter [IClosedSet.EarlyParsableStatusJsonConverter] + nested EarlyParsableStatusTypeConverter : TypeConverter [IClosedSet.EarlyParsableStatusTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : EarlyParsableStatus [IClosedSet.Parse] + static Parse(String, Boolean) : EarlyParsableStatus [IClosedSet.Parse] + static TryParse(String, Boolean, out EarlyParsableStatus) : Boolean [IClosedSet.TryParse] + static TryParse(String, out EarlyParsableStatus) : Boolean [IClosedSet.TryParse] EarlyParseStatus - Match(Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested EarlyParseStatusJsonConverter : JsonConverter - nested EarlyParseStatusTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : EarlyParseStatus - static Parse(String, Boolean) : EarlyParseStatus - static TryParse(String, Boolean, out EarlyParseStatus) : Boolean - static TryParse(String, out EarlyParseStatus) : Boolean + nested EarlyParseStatusJsonConverter : JsonConverter [IClosedSet.EarlyParseStatusJsonConverter] + nested EarlyParseStatusTypeConverter : TypeConverter [IClosedSet.EarlyParseStatusTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : EarlyParseStatus [IClosedSet.Parse] + static Parse(String, Boolean) : EarlyParseStatus [IClosedSet.Parse] + static TryParse(String, Boolean, out EarlyParseStatus) : Boolean [IClosedSet.TryParse] + static TryParse(String, out EarlyParseStatus) : Boolean [IClosedSet.TryParse] EarlyTryParseStatus - Match(Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested EarlyTryParseStatusJsonConverter : JsonConverter - nested EarlyTryParseStatusTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : EarlyTryParseStatus - static Parse(String, Boolean) : EarlyTryParseStatus - static TryParse(String, Boolean, out EarlyTryParseStatus) : Boolean - static TryParse(String, out EarlyTryParseStatus) : Boolean + nested EarlyTryParseStatusJsonConverter : JsonConverter [IClosedSet.EarlyTryParseStatusJsonConverter] + nested EarlyTryParseStatusTypeConverter : TypeConverter [IClosedSet.EarlyTryParseStatusTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : EarlyTryParseStatus [IClosedSet.Parse] + static Parse(String, Boolean) : EarlyTryParseStatus [IClosedSet.Parse] + static TryParse(String, Boolean, out EarlyTryParseStatus) : Boolean [IClosedSet.TryParse] + static TryParse(String, out EarlyTryParseStatus) : Boolean [IClosedSet.TryParse] EqualityOverloadedByArity - CompareTo(EqualityOverloadedByArity) : Int32 - CompareTo(Object) : Int32 + CompareTo(EqualityOverloadedByArity) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(EqualityOverloadedByArity) : Boolean Equals(Object) : Boolean Equals(EqualityOverloadedByArity) : Boolean GetHashCode() : Int32 GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2639,41 +2639,41 @@ EqualityOverloadedByArity implements IValue implements IValueObject implements IValueObjectMaterializer - nested EqualityOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource - nested EqualityOverloadedByArityTypeConverter : TypeConverter + nested EqualityOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.EqualityOverloadedByArityJsonConverter] + nested EqualityOverloadedByArityTypeConverter : TypeConverter [IValue.EqualityOverloadedByArityTypeConverter] new() - static From(Int32) : EqualityOverloadedByArity - static MaxValue : EqualityOverloadedByArity - static MinValue : EqualityOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : EqualityOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : EqualityOverloadedByArity - static Parse(String, IFormatProvider) : EqualityOverloadedByArity - static TryParse(ReadOnlySpan, IFormatProvider, out EqualityOverloadedByArity) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out EqualityOverloadedByArity) : Boolean - static TryParse(String, IFormatProvider, out EqualityOverloadedByArity) : Boolean + static From(Int32) : EqualityOverloadedByArity [IPlainValueObject.From] + static MaxValue : EqualityOverloadedByArity [IMinMaxValue.MaxValue] + static MinValue : EqualityOverloadedByArity [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : EqualityOverloadedByArity [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : EqualityOverloadedByArity [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : EqualityOverloadedByArity [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out EqualityOverloadedByArity) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out EqualityOverloadedByArity) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out EqualityOverloadedByArity) : Boolean [IParsable.TryParse] static op_Equality(EqualityOverloadedByArity, EqualityOverloadedByArity) : Boolean - static op_GreaterThan(EqualityOverloadedByArity, EqualityOverloadedByArity) : Boolean - static op_GreaterThanOrEqual(EqualityOverloadedByArity, EqualityOverloadedByArity) : Boolean + static op_GreaterThan(EqualityOverloadedByArity, EqualityOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(EqualityOverloadedByArity, EqualityOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(EqualityOverloadedByArity, EqualityOverloadedByArity) : Boolean - static op_LessThan(EqualityOverloadedByArity, EqualityOverloadedByArity) : Boolean - static op_LessThanOrEqual(EqualityOverloadedByArity, EqualityOverloadedByArity) : Boolean - extension static EqualityOverloadedByArityExtensions.GetValue(EqualityOverloadedByArity) : Int32 - extension static EqualityOverloadedByArityExtensions.ValueOrNull(EqualityOverloadedByArity?) : Int32? + static op_LessThan(EqualityOverloadedByArity, EqualityOverloadedByArity) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(EqualityOverloadedByArity, EqualityOverloadedByArity) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static EqualityOverloadedByArityExtensions.GetValue(EqualityOverloadedByArity) : Int32 [IValueObject.Value] + extension static EqualityOverloadedByArityExtensions.ValueOrNull(EqualityOverloadedByArity?) : Int32? [IValueObject.Value] EqualsOverloadOverADeeperExplicitEquality $() : EqualsOverloadOverADeeperExplicitEquality - CompareTo(EqualsOverloadOverADeeperExplicitEquality) : Int32 - CompareTo(Object) : Int32 + CompareTo(EqualsOverloadOverADeeperExplicitEquality) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(EqualsOverloadOverADeeperExplicitEquality) : Boolean Equals(LocalBetweenRecord) : Boolean - Equals(LocalExplicitEqualityRecord) : Boolean + Equals(LocalExplicitEqualityRecord) : Boolean [IEquatable.Equals] Equals(Object) : Boolean Equals(LocalExplicitEqualityRecord) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2699,36 +2699,36 @@ EqualsOverloadOverADeeperExplicitEquality implements IValue implements IValueObject implements IValueObjectMaterializer - nested EqualsOverloadOverADeeperExplicitEqualityJsonConverter : JsonConverter, IStoredJsonConverterSource - nested EqualsOverloadOverADeeperExplicitEqualityTypeConverter : TypeConverter - static From(Int32) : EqualsOverloadOverADeeperExplicitEquality - static MaxValue : EqualsOverloadOverADeeperExplicitEquality - static MinValue : EqualsOverloadOverADeeperExplicitEquality - static Parse(ReadOnlySpan, IFormatProvider) : EqualsOverloadOverADeeperExplicitEquality - static Parse(ReadOnlySpan, IFormatProvider) : EqualsOverloadOverADeeperExplicitEquality - static Parse(String, IFormatProvider) : EqualsOverloadOverADeeperExplicitEquality - static TryParse(ReadOnlySpan, IFormatProvider, out EqualsOverloadOverADeeperExplicitEquality) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out EqualsOverloadOverADeeperExplicitEquality) : Boolean - static TryParse(String, IFormatProvider, out EqualsOverloadOverADeeperExplicitEquality) : Boolean + nested EqualsOverloadOverADeeperExplicitEqualityJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.EqualsOverloadOverADeeperExplicitEqualityJsonConverter] + nested EqualsOverloadOverADeeperExplicitEqualityTypeConverter : TypeConverter [IValue.EqualsOverloadOverADeeperExplicitEqualityTypeConverter] + static From(Int32) : EqualsOverloadOverADeeperExplicitEquality [IPlainValueObject.From] + static MaxValue : EqualsOverloadOverADeeperExplicitEquality [IMinMaxValue.MaxValue] + static MinValue : EqualsOverloadOverADeeperExplicitEquality [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : EqualsOverloadOverADeeperExplicitEquality [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : EqualsOverloadOverADeeperExplicitEquality [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : EqualsOverloadOverADeeperExplicitEquality [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out EqualsOverloadOverADeeperExplicitEquality) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out EqualsOverloadOverADeeperExplicitEquality) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out EqualsOverloadOverADeeperExplicitEquality) : Boolean [IParsable.TryParse] static op_Equality(EqualsOverloadOverADeeperExplicitEquality, EqualsOverloadOverADeeperExplicitEquality) : Boolean - static op_GreaterThan(EqualsOverloadOverADeeperExplicitEquality, EqualsOverloadOverADeeperExplicitEquality) : Boolean - static op_GreaterThanOrEqual(EqualsOverloadOverADeeperExplicitEquality, EqualsOverloadOverADeeperExplicitEquality) : Boolean + static op_GreaterThan(EqualsOverloadOverADeeperExplicitEquality, EqualsOverloadOverADeeperExplicitEquality) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(EqualsOverloadOverADeeperExplicitEquality, EqualsOverloadOverADeeperExplicitEquality) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(EqualsOverloadOverADeeperExplicitEquality, EqualsOverloadOverADeeperExplicitEquality) : Boolean - static op_LessThan(EqualsOverloadOverADeeperExplicitEquality, EqualsOverloadOverADeeperExplicitEquality) : Boolean - static op_LessThanOrEqual(EqualsOverloadOverADeeperExplicitEquality, EqualsOverloadOverADeeperExplicitEquality) : Boolean - extension static EqualsOverloadOverADeeperExplicitEqualityExtensions.GetValue(EqualsOverloadOverADeeperExplicitEquality) : Int32 - extension static EqualsOverloadOverADeeperExplicitEqualityExtensions.ValueOrNull(EqualsOverloadOverADeeperExplicitEquality) : Int32? + static op_LessThan(EqualsOverloadOverADeeperExplicitEquality, EqualsOverloadOverADeeperExplicitEquality) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(EqualsOverloadOverADeeperExplicitEquality, EqualsOverloadOverADeeperExplicitEquality) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static EqualsOverloadOverADeeperExplicitEqualityExtensions.GetValue(EqualsOverloadOverADeeperExplicitEquality) : Int32 [IValueObject.Value] + extension static EqualsOverloadOverADeeperExplicitEqualityExtensions.ValueOrNull(EqualsOverloadOverADeeperExplicitEquality) : Int32? [IValueObject.Value] ExplicitlyAdded - CompareTo(ExplicitlyAdded) : Int32 - CompareTo(Object) : Int32 + CompareTo(ExplicitlyAdded) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(ExplicitlyAdded) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2751,37 +2751,37 @@ ExplicitlyAdded implements IValue implements IValueObject implements IValueObjectMaterializer - nested ExplicitlyAddedJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ExplicitlyAddedTypeConverter : TypeConverter + nested ExplicitlyAddedJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ExplicitlyAddedJsonConverter] + nested ExplicitlyAddedTypeConverter : TypeConverter [IValue.ExplicitlyAddedTypeConverter] new() - static From(Int32) : ExplicitlyAdded - static MaxValue : ExplicitlyAdded - static MinValue : ExplicitlyAdded - static Parse(ReadOnlySpan, IFormatProvider) : ExplicitlyAdded - static Parse(ReadOnlySpan, IFormatProvider) : ExplicitlyAdded - static Parse(String, IFormatProvider) : ExplicitlyAdded - static TryParse(ReadOnlySpan, IFormatProvider, out ExplicitlyAdded) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ExplicitlyAdded) : Boolean - static TryParse(String, IFormatProvider, out ExplicitlyAdded) : Boolean + static From(Int32) : ExplicitlyAdded [IPlainValueObject.From] + static MaxValue : ExplicitlyAdded [IMinMaxValue.MaxValue] + static MinValue : ExplicitlyAdded [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ExplicitlyAdded [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ExplicitlyAdded [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ExplicitlyAdded [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ExplicitlyAdded) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ExplicitlyAdded) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ExplicitlyAdded) : Boolean [IParsable.TryParse] static op_Equality(ExplicitlyAdded, ExplicitlyAdded) : Boolean - static op_GreaterThan(ExplicitlyAdded, ExplicitlyAdded) : Boolean - static op_GreaterThanOrEqual(ExplicitlyAdded, ExplicitlyAdded) : Boolean + static op_GreaterThan(ExplicitlyAdded, ExplicitlyAdded) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ExplicitlyAdded, ExplicitlyAdded) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ExplicitlyAdded, ExplicitlyAdded) : Boolean - static op_LessThan(ExplicitlyAdded, ExplicitlyAdded) : Boolean - static op_LessThanOrEqual(ExplicitlyAdded, ExplicitlyAdded) : Boolean - extension static ExplicitlyAddedExtensions.GetValue(ExplicitlyAdded) : Int32 - extension static ExplicitlyAddedExtensions.ValueOrNull(ExplicitlyAdded?) : Int32? + static op_LessThan(ExplicitlyAdded, ExplicitlyAdded) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ExplicitlyAdded, ExplicitlyAdded) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ExplicitlyAddedExtensions.GetValue(ExplicitlyAdded) : Int32 [IValueObject.Value] + extension static ExplicitlyAddedExtensions.ValueOrNull(ExplicitlyAdded?) : Int32? [IValueObject.Value] FeeMoney - CompareTo(FeeMoney) : Int32 - CompareTo(Object) : Int32 + CompareTo(FeeMoney) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(FeeMoney) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Decimal + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Decimal [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2806,40 +2806,40 @@ FeeMoney implements IValue implements IValueObject implements IValueObjectMaterializer - nested FeeMoneyJsonConverter : JsonConverter, IStoredJsonConverterSource - nested FeeMoneyTypeConverter : TypeConverter + nested FeeMoneyJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.FeeMoneyJsonConverter] + nested FeeMoneyTypeConverter : TypeConverter [IValue.FeeMoneyTypeConverter] new() - static From(Decimal) : FeeMoney - static MaxValue : FeeMoney - static MinValue : FeeMoney - static Parse(ReadOnlySpan, IFormatProvider) : FeeMoney - static Parse(ReadOnlySpan, IFormatProvider) : FeeMoney - static Parse(String, IFormatProvider) : FeeMoney - static TryParse(ReadOnlySpan, IFormatProvider, out FeeMoney) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out FeeMoney) : Boolean - static TryParse(String, IFormatProvider, out FeeMoney) : Boolean - static op_CheckedSubtraction(FeeMoney, FeeMoney) : FeeMoney + static From(Decimal) : FeeMoney [IPlainValueObject.From] + static MaxValue : FeeMoney [IMinMaxValue.MaxValue] + static MinValue : FeeMoney [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : FeeMoney [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : FeeMoney [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : FeeMoney [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out FeeMoney) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out FeeMoney) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out FeeMoney) : Boolean [IParsable.TryParse] + static op_CheckedSubtraction(FeeMoney, FeeMoney) : FeeMoney [ISubtractionOperators.op_CheckedSubtraction] static op_Equality(FeeMoney, FeeMoney) : Boolean - static op_GreaterThan(FeeMoney, FeeMoney) : Boolean - static op_GreaterThanOrEqual(FeeMoney, FeeMoney) : Boolean + static op_GreaterThan(FeeMoney, FeeMoney) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(FeeMoney, FeeMoney) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(FeeMoney, FeeMoney) : Boolean - static op_LessThan(FeeMoney, FeeMoney) : Boolean - static op_LessThanOrEqual(FeeMoney, FeeMoney) : Boolean - static op_Subtraction(FeeMoney, FeeMoney) : FeeMoney - extension static FeeMoneyExtensions.GetValue(FeeMoney) : Decimal - extension static FeeMoneyExtensions.ValueOrNull(FeeMoney?) : Decimal? + static op_LessThan(FeeMoney, FeeMoney) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(FeeMoney, FeeMoney) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Subtraction(FeeMoney, FeeMoney) : FeeMoney [ISubtractionOperators.op_Subtraction] + extension static FeeMoneyExtensions.GetValue(FeeMoney) : Decimal [IValueObject.Value] + extension static FeeMoneyExtensions.ValueOrNull(FeeMoney?) : Decimal? [IValueObject.Value] FormatOverloadedByArity - CompareTo(FormatOverloadedByArity) : Int32 - CompareTo(Object) : Int32 + CompareTo(FormatOverloadedByArity) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(FormatOverloadedByArity) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String + ToString(String, IFormatProvider) : String [IFormattable.ToString] ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2861,38 +2861,38 @@ FormatOverloadedByArity implements IValue implements IValueObject implements IValueObjectMaterializer - nested FormatOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource - nested FormatOverloadedByArityTypeConverter : TypeConverter + nested FormatOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.FormatOverloadedByArityJsonConverter] + nested FormatOverloadedByArityTypeConverter : TypeConverter [IValue.FormatOverloadedByArityTypeConverter] new() - static From(Int32) : FormatOverloadedByArity - static MaxValue : FormatOverloadedByArity - static MinValue : FormatOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : FormatOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : FormatOverloadedByArity - static Parse(String, IFormatProvider) : FormatOverloadedByArity - static TryParse(ReadOnlySpan, IFormatProvider, out FormatOverloadedByArity) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out FormatOverloadedByArity) : Boolean - static TryParse(String, IFormatProvider, out FormatOverloadedByArity) : Boolean + static From(Int32) : FormatOverloadedByArity [IPlainValueObject.From] + static MaxValue : FormatOverloadedByArity [IMinMaxValue.MaxValue] + static MinValue : FormatOverloadedByArity [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : FormatOverloadedByArity [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : FormatOverloadedByArity [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : FormatOverloadedByArity [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out FormatOverloadedByArity) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out FormatOverloadedByArity) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out FormatOverloadedByArity) : Boolean [IParsable.TryParse] static op_Equality(FormatOverloadedByArity, FormatOverloadedByArity) : Boolean - static op_GreaterThan(FormatOverloadedByArity, FormatOverloadedByArity) : Boolean - static op_GreaterThanOrEqual(FormatOverloadedByArity, FormatOverloadedByArity) : Boolean + static op_GreaterThan(FormatOverloadedByArity, FormatOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(FormatOverloadedByArity, FormatOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(FormatOverloadedByArity, FormatOverloadedByArity) : Boolean - static op_LessThan(FormatOverloadedByArity, FormatOverloadedByArity) : Boolean - static op_LessThanOrEqual(FormatOverloadedByArity, FormatOverloadedByArity) : Boolean - extension static FormatOverloadedByArityExtensions.GetValue(FormatOverloadedByArity) : Int32 - extension static FormatOverloadedByArityExtensions.ValueOrNull(FormatOverloadedByArity?) : Int32? + static op_LessThan(FormatOverloadedByArity, FormatOverloadedByArity) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(FormatOverloadedByArity, FormatOverloadedByArity) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static FormatOverloadedByArityExtensions.GetValue(FormatOverloadedByArity) : Int32 [IValueObject.Value] + extension static FormatOverloadedByArityExtensions.ValueOrNull(FormatOverloadedByArity?) : Int32? [IValueObject.Value] FormatOverloadedByIn - CompareTo(FormatOverloadedByIn) : Int32 - CompareTo(Object) : Int32 + CompareTo(FormatOverloadedByIn) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(FormatOverloadedByIn) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String + ToString(String, IFormatProvider) : String [IFormattable.ToString] ToString(in String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2914,37 +2914,37 @@ FormatOverloadedByIn implements IValue implements IValueObject implements IValueObjectMaterializer - nested FormatOverloadedByInJsonConverter : JsonConverter, IStoredJsonConverterSource - nested FormatOverloadedByInTypeConverter : TypeConverter + nested FormatOverloadedByInJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.FormatOverloadedByInJsonConverter] + nested FormatOverloadedByInTypeConverter : TypeConverter [IValue.FormatOverloadedByInTypeConverter] new() - static From(Int32) : FormatOverloadedByIn - static MaxValue : FormatOverloadedByIn - static MinValue : FormatOverloadedByIn - static Parse(ReadOnlySpan, IFormatProvider) : FormatOverloadedByIn - static Parse(ReadOnlySpan, IFormatProvider) : FormatOverloadedByIn - static Parse(String, IFormatProvider) : FormatOverloadedByIn - static TryParse(ReadOnlySpan, IFormatProvider, out FormatOverloadedByIn) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out FormatOverloadedByIn) : Boolean - static TryParse(String, IFormatProvider, out FormatOverloadedByIn) : Boolean + static From(Int32) : FormatOverloadedByIn [IPlainValueObject.From] + static MaxValue : FormatOverloadedByIn [IMinMaxValue.MaxValue] + static MinValue : FormatOverloadedByIn [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : FormatOverloadedByIn [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : FormatOverloadedByIn [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : FormatOverloadedByIn [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out FormatOverloadedByIn) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out FormatOverloadedByIn) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out FormatOverloadedByIn) : Boolean [IParsable.TryParse] static op_Equality(FormatOverloadedByIn, FormatOverloadedByIn) : Boolean - static op_GreaterThan(FormatOverloadedByIn, FormatOverloadedByIn) : Boolean - static op_GreaterThanOrEqual(FormatOverloadedByIn, FormatOverloadedByIn) : Boolean + static op_GreaterThan(FormatOverloadedByIn, FormatOverloadedByIn) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(FormatOverloadedByIn, FormatOverloadedByIn) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(FormatOverloadedByIn, FormatOverloadedByIn) : Boolean - static op_LessThan(FormatOverloadedByIn, FormatOverloadedByIn) : Boolean - static op_LessThanOrEqual(FormatOverloadedByIn, FormatOverloadedByIn) : Boolean - extension static FormatOverloadedByInExtensions.GetValue(FormatOverloadedByIn) : Int32 - extension static FormatOverloadedByInExtensions.ValueOrNull(FormatOverloadedByIn?) : Int32? + static op_LessThan(FormatOverloadedByIn, FormatOverloadedByIn) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(FormatOverloadedByIn, FormatOverloadedByIn) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static FormatOverloadedByInExtensions.GetValue(FormatOverloadedByIn) : Int32 [IValueObject.Value] + extension static FormatOverloadedByInExtensions.ValueOrNull(FormatOverloadedByIn?) : Int32? [IValueObject.Value] FromOverloadedByArity - CompareTo(FromOverloadedByArity) : Int32 - CompareTo(Object) : Int32 + CompareTo(FromOverloadedByArity) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(FromOverloadedByArity) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -2966,38 +2966,38 @@ FromOverloadedByArity implements IValue implements IValueObject implements IValueObjectMaterializer - nested FromOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource - nested FromOverloadedByArityTypeConverter : TypeConverter + nested FromOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.FromOverloadedByArityJsonConverter] + nested FromOverloadedByArityTypeConverter : TypeConverter [IValue.FromOverloadedByArityTypeConverter] new() - static From(Int32) : FromOverloadedByArity + static From(Int32) : FromOverloadedByArity [IPlainValueObject.From] static From(Int32) : FromOverloadedByArity - static MaxValue : FromOverloadedByArity - static MinValue : FromOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : FromOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : FromOverloadedByArity - static Parse(String, IFormatProvider) : FromOverloadedByArity - static TryParse(ReadOnlySpan, IFormatProvider, out FromOverloadedByArity) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out FromOverloadedByArity) : Boolean - static TryParse(String, IFormatProvider, out FromOverloadedByArity) : Boolean + static MaxValue : FromOverloadedByArity [IMinMaxValue.MaxValue] + static MinValue : FromOverloadedByArity [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : FromOverloadedByArity [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : FromOverloadedByArity [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : FromOverloadedByArity [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out FromOverloadedByArity) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out FromOverloadedByArity) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out FromOverloadedByArity) : Boolean [IParsable.TryParse] static op_Equality(FromOverloadedByArity, FromOverloadedByArity) : Boolean - static op_GreaterThan(FromOverloadedByArity, FromOverloadedByArity) : Boolean - static op_GreaterThanOrEqual(FromOverloadedByArity, FromOverloadedByArity) : Boolean + static op_GreaterThan(FromOverloadedByArity, FromOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(FromOverloadedByArity, FromOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(FromOverloadedByArity, FromOverloadedByArity) : Boolean - static op_LessThan(FromOverloadedByArity, FromOverloadedByArity) : Boolean - static op_LessThanOrEqual(FromOverloadedByArity, FromOverloadedByArity) : Boolean - extension static FromOverloadedByArityExtensions.GetValue(FromOverloadedByArity) : Int32 - extension static FromOverloadedByArityExtensions.ValueOrNull(FromOverloadedByArity?) : Int32? + static op_LessThan(FromOverloadedByArity, FromOverloadedByArity) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(FromOverloadedByArity, FromOverloadedByArity) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static FromOverloadedByArityExtensions.GetValue(FromOverloadedByArity) : Int32 [IValueObject.Value] + extension static FromOverloadedByArityExtensions.ValueOrNull(FromOverloadedByArity?) : Int32? [IValueObject.Value] FromOverloadedByIn - CompareTo(FromOverloadedByIn) : Int32 - CompareTo(Object) : Int32 + CompareTo(FromOverloadedByIn) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(FromOverloadedByIn) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3019,38 +3019,38 @@ FromOverloadedByIn implements IValue implements IValueObject implements IValueObjectMaterializer - nested FromOverloadedByInJsonConverter : JsonConverter, IStoredJsonConverterSource - nested FromOverloadedByInTypeConverter : TypeConverter + nested FromOverloadedByInJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.FromOverloadedByInJsonConverter] + nested FromOverloadedByInTypeConverter : TypeConverter [IValue.FromOverloadedByInTypeConverter] new() - static From(Int32) : FromOverloadedByIn + static From(Int32) : FromOverloadedByIn [IPlainValueObject.From] static From(in Int32) : FromOverloadedByIn - static MaxValue : FromOverloadedByIn - static MinValue : FromOverloadedByIn - static Parse(ReadOnlySpan, IFormatProvider) : FromOverloadedByIn - static Parse(ReadOnlySpan, IFormatProvider) : FromOverloadedByIn - static Parse(String, IFormatProvider) : FromOverloadedByIn - static TryParse(ReadOnlySpan, IFormatProvider, out FromOverloadedByIn) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out FromOverloadedByIn) : Boolean - static TryParse(String, IFormatProvider, out FromOverloadedByIn) : Boolean + static MaxValue : FromOverloadedByIn [IMinMaxValue.MaxValue] + static MinValue : FromOverloadedByIn [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : FromOverloadedByIn [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : FromOverloadedByIn [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : FromOverloadedByIn [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out FromOverloadedByIn) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out FromOverloadedByIn) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out FromOverloadedByIn) : Boolean [IParsable.TryParse] static op_Equality(FromOverloadedByIn, FromOverloadedByIn) : Boolean - static op_GreaterThan(FromOverloadedByIn, FromOverloadedByIn) : Boolean - static op_GreaterThanOrEqual(FromOverloadedByIn, FromOverloadedByIn) : Boolean + static op_GreaterThan(FromOverloadedByIn, FromOverloadedByIn) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(FromOverloadedByIn, FromOverloadedByIn) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(FromOverloadedByIn, FromOverloadedByIn) : Boolean - static op_LessThan(FromOverloadedByIn, FromOverloadedByIn) : Boolean - static op_LessThanOrEqual(FromOverloadedByIn, FromOverloadedByIn) : Boolean - extension static FromOverloadedByInExtensions.GetValue(FromOverloadedByIn) : Int32 - extension static FromOverloadedByInExtensions.ValueOrNull(FromOverloadedByIn?) : Int32? + static op_LessThan(FromOverloadedByIn, FromOverloadedByIn) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(FromOverloadedByIn, FromOverloadedByIn) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static FromOverloadedByInExtensions.GetValue(FromOverloadedByIn) : Int32 [IValueObject.Value] + extension static FromOverloadedByInExtensions.ValueOrNull(FromOverloadedByIn?) : Int32? [IValueObject.Value] FromOverloadedByRef - CompareTo(FromOverloadedByRef) : Int32 - CompareTo(Object) : Int32 + CompareTo(FromOverloadedByRef) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(FromOverloadedByRef) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3072,38 +3072,38 @@ FromOverloadedByRef implements IValue implements IValueObject implements IValueObjectMaterializer - nested FromOverloadedByRefJsonConverter : JsonConverter, IStoredJsonConverterSource - nested FromOverloadedByRefTypeConverter : TypeConverter + nested FromOverloadedByRefJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.FromOverloadedByRefJsonConverter] + nested FromOverloadedByRefTypeConverter : TypeConverter [IValue.FromOverloadedByRefTypeConverter] new() - static From(Int32) : FromOverloadedByRef + static From(Int32) : FromOverloadedByRef [IPlainValueObject.From] static From(ref Int32) : FromOverloadedByRef - static MaxValue : FromOverloadedByRef - static MinValue : FromOverloadedByRef - static Parse(ReadOnlySpan, IFormatProvider) : FromOverloadedByRef - static Parse(ReadOnlySpan, IFormatProvider) : FromOverloadedByRef - static Parse(String, IFormatProvider) : FromOverloadedByRef - static TryParse(ReadOnlySpan, IFormatProvider, out FromOverloadedByRef) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out FromOverloadedByRef) : Boolean - static TryParse(String, IFormatProvider, out FromOverloadedByRef) : Boolean + static MaxValue : FromOverloadedByRef [IMinMaxValue.MaxValue] + static MinValue : FromOverloadedByRef [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : FromOverloadedByRef [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : FromOverloadedByRef [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : FromOverloadedByRef [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out FromOverloadedByRef) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out FromOverloadedByRef) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out FromOverloadedByRef) : Boolean [IParsable.TryParse] static op_Equality(FromOverloadedByRef, FromOverloadedByRef) : Boolean - static op_GreaterThan(FromOverloadedByRef, FromOverloadedByRef) : Boolean - static op_GreaterThanOrEqual(FromOverloadedByRef, FromOverloadedByRef) : Boolean + static op_GreaterThan(FromOverloadedByRef, FromOverloadedByRef) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(FromOverloadedByRef, FromOverloadedByRef) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(FromOverloadedByRef, FromOverloadedByRef) : Boolean - static op_LessThan(FromOverloadedByRef, FromOverloadedByRef) : Boolean - static op_LessThanOrEqual(FromOverloadedByRef, FromOverloadedByRef) : Boolean - extension static FromOverloadedByRefExtensions.GetValue(FromOverloadedByRef) : Int32 - extension static FromOverloadedByRefExtensions.ValueOrNull(FromOverloadedByRef?) : Int32? + static op_LessThan(FromOverloadedByRef, FromOverloadedByRef) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(FromOverloadedByRef, FromOverloadedByRef) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static FromOverloadedByRefExtensions.GetValue(FromOverloadedByRef) : Int32 [IValueObject.Value] + extension static FromOverloadedByRefExtensions.ValueOrNull(FromOverloadedByRef?) : Int32? [IValueObject.Value] HalfAmount - CompareTo(HalfAmount) : Int32 - CompareTo(Object) : Int32 + CompareTo(HalfAmount) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(HalfAmount) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Half + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Half [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3132,51 +3132,51 @@ HalfAmount implements IValue implements IValueObject implements IValueObjectMaterializer - nested HalfAmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested HalfAmountTypeConverter : TypeConverter + nested HalfAmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.HalfAmountJsonConverter] + nested HalfAmountTypeConverter : TypeConverter [IValue.HalfAmountTypeConverter] new() - static From(Half) : HalfAmount - static MaxValue : HalfAmount - static MinValue : HalfAmount - static Parse(ReadOnlySpan, IFormatProvider) : HalfAmount - static Parse(ReadOnlySpan, IFormatProvider) : HalfAmount - static Parse(String, IFormatProvider) : HalfAmount - static TryParse(ReadOnlySpan, IFormatProvider, out HalfAmount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out HalfAmount) : Boolean - static TryParse(String, IFormatProvider, out HalfAmount) : Boolean - static op_Addition(HalfAmount, HalfAmount) : HalfAmount - static op_CheckedAddition(HalfAmount, HalfAmount) : HalfAmount - static op_CheckedDivision(HalfAmount, HalfAmount) : HalfAmount - static op_CheckedMultiply(HalfAmount, HalfAmount) : HalfAmount - static op_CheckedSubtraction(HalfAmount, HalfAmount) : HalfAmount - static op_CheckedUnaryNegation(HalfAmount) : HalfAmount - static op_Division(HalfAmount, HalfAmount) : HalfAmount + static From(Half) : HalfAmount [IPlainValueObject.From] + static MaxValue : HalfAmount [IMinMaxValue.MaxValue] + static MinValue : HalfAmount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : HalfAmount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : HalfAmount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : HalfAmount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out HalfAmount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out HalfAmount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out HalfAmount) : Boolean [IParsable.TryParse] + static op_Addition(HalfAmount, HalfAmount) : HalfAmount [IAdditionOperators.op_Addition] + static op_CheckedAddition(HalfAmount, HalfAmount) : HalfAmount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(HalfAmount, HalfAmount) : HalfAmount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(HalfAmount, HalfAmount) : HalfAmount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(HalfAmount, HalfAmount) : HalfAmount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(HalfAmount) : HalfAmount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(HalfAmount, HalfAmount) : HalfAmount [IDivisionOperators.op_Division] static op_Equality(HalfAmount, HalfAmount) : Boolean - static op_GreaterThan(HalfAmount, HalfAmount) : Boolean - static op_GreaterThanOrEqual(HalfAmount, HalfAmount) : Boolean + static op_GreaterThan(HalfAmount, HalfAmount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(HalfAmount, HalfAmount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(HalfAmount, HalfAmount) : Boolean - static op_LessThan(HalfAmount, HalfAmount) : Boolean - static op_LessThanOrEqual(HalfAmount, HalfAmount) : Boolean - static op_Modulus(HalfAmount, HalfAmount) : HalfAmount - static op_Multiply(HalfAmount, HalfAmount) : HalfAmount - static op_Subtraction(HalfAmount, HalfAmount) : HalfAmount - static op_UnaryNegation(HalfAmount) : HalfAmount - static op_UnaryPlus(HalfAmount) : HalfAmount - extension static HalfAmountExtensions.GetValue(HalfAmount) : Half - extension static HalfAmountExtensions.ValueOrNull(HalfAmount?) : Half? + static op_LessThan(HalfAmount, HalfAmount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(HalfAmount, HalfAmount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(HalfAmount, HalfAmount) : HalfAmount [IModulusOperators.op_Modulus] + static op_Multiply(HalfAmount, HalfAmount) : HalfAmount [IMultiplyOperators.op_Multiply] + static op_Subtraction(HalfAmount, HalfAmount) : HalfAmount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(HalfAmount) : HalfAmount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(HalfAmount) : HalfAmount [IUnaryPlusOperators.op_UnaryPlus] + extension static HalfAmountExtensions.GetValue(HalfAmount) : Half [IValueObject.Value] + extension static HalfAmountExtensions.ValueOrNull(HalfAmount?) : Half? [IValueObject.Value] InheritsAddition $() : InheritsAddition - CompareTo(InheritsAddition) : Int32 - CompareTo(Object) : Int32 + CompareTo(InheritsAddition) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(AddingBase) : Boolean Equals(InheritsAddition) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3201,36 +3201,36 @@ InheritsAddition implements IValue implements IValueObject implements IValueObjectMaterializer - nested InheritsAdditionJsonConverter : JsonConverter, IStoredJsonConverterSource - nested InheritsAdditionTypeConverter : TypeConverter - static From(Int32) : InheritsAddition - static MaxValue : InheritsAddition - static MinValue : InheritsAddition - static Parse(ReadOnlySpan, IFormatProvider) : InheritsAddition - static Parse(ReadOnlySpan, IFormatProvider) : InheritsAddition - static Parse(String, IFormatProvider) : InheritsAddition - static TryParse(ReadOnlySpan, IFormatProvider, out InheritsAddition) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out InheritsAddition) : Boolean - static TryParse(String, IFormatProvider, out InheritsAddition) : Boolean + nested InheritsAdditionJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.InheritsAdditionJsonConverter] + nested InheritsAdditionTypeConverter : TypeConverter [IValue.InheritsAdditionTypeConverter] + static From(Int32) : InheritsAddition [IPlainValueObject.From] + static MaxValue : InheritsAddition [IMinMaxValue.MaxValue] + static MinValue : InheritsAddition [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : InheritsAddition [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : InheritsAddition [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : InheritsAddition [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out InheritsAddition) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out InheritsAddition) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out InheritsAddition) : Boolean [IParsable.TryParse] static op_Equality(InheritsAddition, InheritsAddition) : Boolean - static op_GreaterThan(InheritsAddition, InheritsAddition) : Boolean - static op_GreaterThanOrEqual(InheritsAddition, InheritsAddition) : Boolean + static op_GreaterThan(InheritsAddition, InheritsAddition) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(InheritsAddition, InheritsAddition) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(InheritsAddition, InheritsAddition) : Boolean - static op_LessThan(InheritsAddition, InheritsAddition) : Boolean - static op_LessThanOrEqual(InheritsAddition, InheritsAddition) : Boolean - extension static InheritsAdditionExtensions.GetValue(InheritsAddition) : Int32 - extension static InheritsAdditionExtensions.ValueOrNull(InheritsAddition) : Int32? + static op_LessThan(InheritsAddition, InheritsAddition) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(InheritsAddition, InheritsAddition) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static InheritsAdditionExtensions.GetValue(InheritsAddition) : Int32 [IValueObject.Value] + extension static InheritsAdditionExtensions.ValueOrNull(InheritsAddition) : Int32? [IValueObject.Value] Int128Amount - CompareTo(Int128Amount) : Int32 - CompareTo(Object) : Int32 + CompareTo(Int128Amount) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(Int128Amount) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int128 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int128 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3259,49 +3259,49 @@ Int128Amount implements IValue implements IValueObject implements IValueObjectMaterializer - nested Int128AmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested Int128AmountTypeConverter : TypeConverter + nested Int128AmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.Int128AmountJsonConverter] + nested Int128AmountTypeConverter : TypeConverter [IValue.Int128AmountTypeConverter] new() - static From(Int128) : Int128Amount - static MaxValue : Int128Amount - static MinValue : Int128Amount - static Parse(ReadOnlySpan, IFormatProvider) : Int128Amount - static Parse(ReadOnlySpan, IFormatProvider) : Int128Amount - static Parse(String, IFormatProvider) : Int128Amount - static TryParse(ReadOnlySpan, IFormatProvider, out Int128Amount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out Int128Amount) : Boolean - static TryParse(String, IFormatProvider, out Int128Amount) : Boolean - static op_Addition(Int128Amount, Int128Amount) : Int128Amount - static op_CheckedAddition(Int128Amount, Int128Amount) : Int128Amount - static op_CheckedDivision(Int128Amount, Int128Amount) : Int128Amount - static op_CheckedMultiply(Int128Amount, Int128Amount) : Int128Amount - static op_CheckedSubtraction(Int128Amount, Int128Amount) : Int128Amount - static op_CheckedUnaryNegation(Int128Amount) : Int128Amount - static op_Division(Int128Amount, Int128Amount) : Int128Amount + static From(Int128) : Int128Amount [IPlainValueObject.From] + static MaxValue : Int128Amount [IMinMaxValue.MaxValue] + static MinValue : Int128Amount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : Int128Amount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : Int128Amount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : Int128Amount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out Int128Amount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out Int128Amount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out Int128Amount) : Boolean [IParsable.TryParse] + static op_Addition(Int128Amount, Int128Amount) : Int128Amount [IAdditionOperators.op_Addition] + static op_CheckedAddition(Int128Amount, Int128Amount) : Int128Amount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(Int128Amount, Int128Amount) : Int128Amount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(Int128Amount, Int128Amount) : Int128Amount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(Int128Amount, Int128Amount) : Int128Amount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(Int128Amount) : Int128Amount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(Int128Amount, Int128Amount) : Int128Amount [IDivisionOperators.op_Division] static op_Equality(Int128Amount, Int128Amount) : Boolean - static op_GreaterThan(Int128Amount, Int128Amount) : Boolean - static op_GreaterThanOrEqual(Int128Amount, Int128Amount) : Boolean + static op_GreaterThan(Int128Amount, Int128Amount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(Int128Amount, Int128Amount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(Int128Amount, Int128Amount) : Boolean - static op_LessThan(Int128Amount, Int128Amount) : Boolean - static op_LessThanOrEqual(Int128Amount, Int128Amount) : Boolean - static op_Modulus(Int128Amount, Int128Amount) : Int128Amount - static op_Multiply(Int128Amount, Int128Amount) : Int128Amount - static op_Subtraction(Int128Amount, Int128Amount) : Int128Amount - static op_UnaryNegation(Int128Amount) : Int128Amount - static op_UnaryPlus(Int128Amount) : Int128Amount - extension static Int128AmountExtensions.GetValue(Int128Amount) : Int128 - extension static Int128AmountExtensions.ValueOrNull(Int128Amount?) : Int128? + static op_LessThan(Int128Amount, Int128Amount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(Int128Amount, Int128Amount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(Int128Amount, Int128Amount) : Int128Amount [IModulusOperators.op_Modulus] + static op_Multiply(Int128Amount, Int128Amount) : Int128Amount [IMultiplyOperators.op_Multiply] + static op_Subtraction(Int128Amount, Int128Amount) : Int128Amount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(Int128Amount) : Int128Amount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(Int128Amount) : Int128Amount [IUnaryPlusOperators.op_UnaryPlus] + extension static Int128AmountExtensions.GetValue(Int128Amount) : Int128 [IValueObject.Value] + extension static Int128AmountExtensions.ValueOrNull(Int128Amount?) : Int128? [IValueObject.Value] Int16Amount - CompareTo(Int16Amount) : Int32 - CompareTo(Object) : Int32 + CompareTo(Int16Amount) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(Int16Amount) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int16 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int16 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3331,49 +3331,49 @@ Int16Amount implements IValue implements IValueObject implements IValueObjectMaterializer - nested Int16AmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested Int16AmountTypeConverter : TypeConverter + nested Int16AmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.Int16AmountJsonConverter] + nested Int16AmountTypeConverter : TypeConverter [IValue.Int16AmountTypeConverter] new() - static From(Int16) : Int16Amount - static MaxValue : Int16Amount - static MinValue : Int16Amount - static Parse(ReadOnlySpan, IFormatProvider) : Int16Amount - static Parse(ReadOnlySpan, IFormatProvider) : Int16Amount - static Parse(String, IFormatProvider) : Int16Amount - static TryParse(ReadOnlySpan, IFormatProvider, out Int16Amount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out Int16Amount) : Boolean - static TryParse(String, IFormatProvider, out Int16Amount) : Boolean - static op_Addition(Int16Amount, Int16Amount) : Int16Amount - static op_CheckedAddition(Int16Amount, Int16Amount) : Int16Amount - static op_CheckedDivision(Int16Amount, Int16Amount) : Int16Amount - static op_CheckedMultiply(Int16Amount, Int16Amount) : Int16Amount - static op_CheckedSubtraction(Int16Amount, Int16Amount) : Int16Amount - static op_CheckedUnaryNegation(Int16Amount) : Int16Amount - static op_Division(Int16Amount, Int16Amount) : Int16Amount + static From(Int16) : Int16Amount [IPlainValueObject.From] + static MaxValue : Int16Amount [IMinMaxValue.MaxValue] + static MinValue : Int16Amount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : Int16Amount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : Int16Amount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : Int16Amount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out Int16Amount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out Int16Amount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out Int16Amount) : Boolean [IParsable.TryParse] + static op_Addition(Int16Amount, Int16Amount) : Int16Amount [IAdditionOperators.op_Addition] + static op_CheckedAddition(Int16Amount, Int16Amount) : Int16Amount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(Int16Amount, Int16Amount) : Int16Amount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(Int16Amount, Int16Amount) : Int16Amount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(Int16Amount, Int16Amount) : Int16Amount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(Int16Amount) : Int16Amount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(Int16Amount, Int16Amount) : Int16Amount [IDivisionOperators.op_Division] static op_Equality(Int16Amount, Int16Amount) : Boolean - static op_GreaterThan(Int16Amount, Int16Amount) : Boolean - static op_GreaterThanOrEqual(Int16Amount, Int16Amount) : Boolean + static op_GreaterThan(Int16Amount, Int16Amount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(Int16Amount, Int16Amount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(Int16Amount, Int16Amount) : Boolean - static op_LessThan(Int16Amount, Int16Amount) : Boolean - static op_LessThanOrEqual(Int16Amount, Int16Amount) : Boolean - static op_Modulus(Int16Amount, Int16Amount) : Int16Amount - static op_Multiply(Int16Amount, Int16Amount) : Int16Amount - static op_Subtraction(Int16Amount, Int16Amount) : Int16Amount - static op_UnaryNegation(Int16Amount) : Int16Amount - static op_UnaryPlus(Int16Amount) : Int16Amount - extension static Int16AmountExtensions.GetValue(Int16Amount) : Int16 - extension static Int16AmountExtensions.ValueOrNull(Int16Amount?) : Int16? + static op_LessThan(Int16Amount, Int16Amount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(Int16Amount, Int16Amount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(Int16Amount, Int16Amount) : Int16Amount [IModulusOperators.op_Modulus] + static op_Multiply(Int16Amount, Int16Amount) : Int16Amount [IMultiplyOperators.op_Multiply] + static op_Subtraction(Int16Amount, Int16Amount) : Int16Amount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(Int16Amount) : Int16Amount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(Int16Amount) : Int16Amount [IUnaryPlusOperators.op_UnaryPlus] + extension static Int16AmountExtensions.GetValue(Int16Amount) : Int16 [IValueObject.Value] + extension static Int16AmountExtensions.ValueOrNull(Int16Amount?) : Int16? [IValueObject.Value] Int32Amount - CompareTo(Int32Amount) : Int32 - CompareTo(Object) : Int32 + CompareTo(Int32Amount) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(Int32Amount) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3403,50 +3403,50 @@ Int32Amount implements IValue implements IValueObject implements IValueObjectMaterializer - nested Int32AmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested Int32AmountTypeConverter : TypeConverter + nested Int32AmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.Int32AmountJsonConverter] + nested Int32AmountTypeConverter : TypeConverter [IValue.Int32AmountTypeConverter] new() - static From(Int32) : Int32Amount - static MaxValue : Int32Amount - static MinValue : Int32Amount - static Parse(ReadOnlySpan, IFormatProvider) : Int32Amount - static Parse(ReadOnlySpan, IFormatProvider) : Int32Amount - static Parse(String, IFormatProvider) : Int32Amount - static TryParse(ReadOnlySpan, IFormatProvider, out Int32Amount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out Int32Amount) : Boolean - static TryParse(String, IFormatProvider, out Int32Amount) : Boolean - static op_Addition(Int32Amount, Int32Amount) : Int32Amount - static op_CheckedAddition(Int32Amount, Int32Amount) : Int32Amount - static op_CheckedDivision(Int32Amount, Int32Amount) : Int32Amount - static op_CheckedMultiply(Int32Amount, Int32Amount) : Int32Amount - static op_CheckedSubtraction(Int32Amount, Int32Amount) : Int32Amount - static op_CheckedUnaryNegation(Int32Amount) : Int32Amount - static op_Division(Int32Amount, Int32Amount) : Int32Amount + static From(Int32) : Int32Amount [IPlainValueObject.From] + static MaxValue : Int32Amount [IMinMaxValue.MaxValue] + static MinValue : Int32Amount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : Int32Amount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : Int32Amount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : Int32Amount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out Int32Amount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out Int32Amount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out Int32Amount) : Boolean [IParsable.TryParse] + static op_Addition(Int32Amount, Int32Amount) : Int32Amount [IAdditionOperators.op_Addition] + static op_CheckedAddition(Int32Amount, Int32Amount) : Int32Amount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(Int32Amount, Int32Amount) : Int32Amount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(Int32Amount, Int32Amount) : Int32Amount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(Int32Amount, Int32Amount) : Int32Amount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(Int32Amount) : Int32Amount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(Int32Amount, Int32Amount) : Int32Amount [IDivisionOperators.op_Division] static op_Equality(Int32Amount, Int32Amount) : Boolean - static op_GreaterThan(Int32Amount, Int32Amount) : Boolean - static op_GreaterThanOrEqual(Int32Amount, Int32Amount) : Boolean + static op_GreaterThan(Int32Amount, Int32Amount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(Int32Amount, Int32Amount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(Int32Amount, Int32Amount) : Boolean - static op_LessThan(Int32Amount, Int32Amount) : Boolean - static op_LessThanOrEqual(Int32Amount, Int32Amount) : Boolean - static op_Modulus(Int32Amount, Int32Amount) : Int32Amount - static op_Multiply(Int32Amount, Int32Amount) : Int32Amount - static op_Subtraction(Int32Amount, Int32Amount) : Int32Amount - static op_UnaryNegation(Int32Amount) : Int32Amount - static op_UnaryPlus(Int32Amount) : Int32Amount - extension static Int32AmountExtensions.GetValue(Int32Amount) : Int32 - extension static Int32AmountExtensions.ValueOrNull(Int32Amount?) : Int32? + static op_LessThan(Int32Amount, Int32Amount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(Int32Amount, Int32Amount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(Int32Amount, Int32Amount) : Int32Amount [IModulusOperators.op_Modulus] + static op_Multiply(Int32Amount, Int32Amount) : Int32Amount [IMultiplyOperators.op_Multiply] + static op_Subtraction(Int32Amount, Int32Amount) : Int32Amount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(Int32Amount) : Int32Amount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(Int32Amount) : Int32Amount [IUnaryPlusOperators.op_UnaryPlus] + extension static Int32AmountExtensions.GetValue(Int32Amount) : Int32 [IValueObject.Value] + extension static Int32AmountExtensions.ValueOrNull(Int32Amount?) : Int32? [IValueObject.Value] Int32AmountClass $() : Int32AmountClass - CompareTo(Int32AmountClass) : Int32 - CompareTo(Object) : Int32 + CompareTo(Int32AmountClass) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(Int32AmountClass) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3476,48 +3476,48 @@ Int32AmountClass implements IValue implements IValueObject implements IValueObjectMaterializer - nested Int32AmountClassJsonConverter : JsonConverter, IStoredJsonConverterSource - nested Int32AmountClassTypeConverter : TypeConverter - static From(Int32) : Int32AmountClass - static MaxValue : Int32AmountClass - static MinValue : Int32AmountClass - static Parse(ReadOnlySpan, IFormatProvider) : Int32AmountClass - static Parse(ReadOnlySpan, IFormatProvider) : Int32AmountClass - static Parse(String, IFormatProvider) : Int32AmountClass - static TryParse(ReadOnlySpan, IFormatProvider, out Int32AmountClass) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out Int32AmountClass) : Boolean - static TryParse(String, IFormatProvider, out Int32AmountClass) : Boolean - static op_Addition(Int32AmountClass, Int32AmountClass) : Int32AmountClass - static op_CheckedAddition(Int32AmountClass, Int32AmountClass) : Int32AmountClass - static op_CheckedDivision(Int32AmountClass, Int32AmountClass) : Int32AmountClass - static op_CheckedMultiply(Int32AmountClass, Int32AmountClass) : Int32AmountClass - static op_CheckedSubtraction(Int32AmountClass, Int32AmountClass) : Int32AmountClass - static op_CheckedUnaryNegation(Int32AmountClass) : Int32AmountClass - static op_Division(Int32AmountClass, Int32AmountClass) : Int32AmountClass + nested Int32AmountClassJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.Int32AmountClassJsonConverter] + nested Int32AmountClassTypeConverter : TypeConverter [IValue.Int32AmountClassTypeConverter] + static From(Int32) : Int32AmountClass [IPlainValueObject.From] + static MaxValue : Int32AmountClass [IMinMaxValue.MaxValue] + static MinValue : Int32AmountClass [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : Int32AmountClass [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : Int32AmountClass [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : Int32AmountClass [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out Int32AmountClass) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out Int32AmountClass) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out Int32AmountClass) : Boolean [IParsable.TryParse] + static op_Addition(Int32AmountClass, Int32AmountClass) : Int32AmountClass [IAdditionOperators.op_Addition] + static op_CheckedAddition(Int32AmountClass, Int32AmountClass) : Int32AmountClass [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(Int32AmountClass, Int32AmountClass) : Int32AmountClass [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(Int32AmountClass, Int32AmountClass) : Int32AmountClass [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(Int32AmountClass, Int32AmountClass) : Int32AmountClass [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(Int32AmountClass) : Int32AmountClass [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(Int32AmountClass, Int32AmountClass) : Int32AmountClass [IDivisionOperators.op_Division] static op_Equality(Int32AmountClass, Int32AmountClass) : Boolean - static op_GreaterThan(Int32AmountClass, Int32AmountClass) : Boolean - static op_GreaterThanOrEqual(Int32AmountClass, Int32AmountClass) : Boolean + static op_GreaterThan(Int32AmountClass, Int32AmountClass) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(Int32AmountClass, Int32AmountClass) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(Int32AmountClass, Int32AmountClass) : Boolean - static op_LessThan(Int32AmountClass, Int32AmountClass) : Boolean - static op_LessThanOrEqual(Int32AmountClass, Int32AmountClass) : Boolean - static op_Modulus(Int32AmountClass, Int32AmountClass) : Int32AmountClass - static op_Multiply(Int32AmountClass, Int32AmountClass) : Int32AmountClass - static op_Subtraction(Int32AmountClass, Int32AmountClass) : Int32AmountClass - static op_UnaryNegation(Int32AmountClass) : Int32AmountClass - static op_UnaryPlus(Int32AmountClass) : Int32AmountClass - extension static Int32AmountClassExtensions.GetValue(Int32AmountClass) : Int32 - extension static Int32AmountClassExtensions.ValueOrNull(Int32AmountClass) : Int32? + static op_LessThan(Int32AmountClass, Int32AmountClass) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(Int32AmountClass, Int32AmountClass) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(Int32AmountClass, Int32AmountClass) : Int32AmountClass [IModulusOperators.op_Modulus] + static op_Multiply(Int32AmountClass, Int32AmountClass) : Int32AmountClass [IMultiplyOperators.op_Multiply] + static op_Subtraction(Int32AmountClass, Int32AmountClass) : Int32AmountClass [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(Int32AmountClass) : Int32AmountClass [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(Int32AmountClass) : Int32AmountClass [IUnaryPlusOperators.op_UnaryPlus] + extension static Int32AmountClassExtensions.GetValue(Int32AmountClass) : Int32 [IValueObject.Value] + extension static Int32AmountClassExtensions.ValueOrNull(Int32AmountClass) : Int32? [IValueObject.Value] Int64Amount - CompareTo(Int64Amount) : Int32 - CompareTo(Object) : Int32 + CompareTo(Int64Amount) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(Int64Amount) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int64 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int64 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3547,49 +3547,49 @@ Int64Amount implements IValue implements IValueObject implements IValueObjectMaterializer - nested Int64AmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested Int64AmountTypeConverter : TypeConverter + nested Int64AmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.Int64AmountJsonConverter] + nested Int64AmountTypeConverter : TypeConverter [IValue.Int64AmountTypeConverter] new() - static From(Int64) : Int64Amount - static MaxValue : Int64Amount - static MinValue : Int64Amount - static Parse(ReadOnlySpan, IFormatProvider) : Int64Amount - static Parse(ReadOnlySpan, IFormatProvider) : Int64Amount - static Parse(String, IFormatProvider) : Int64Amount - static TryParse(ReadOnlySpan, IFormatProvider, out Int64Amount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out Int64Amount) : Boolean - static TryParse(String, IFormatProvider, out Int64Amount) : Boolean - static op_Addition(Int64Amount, Int64Amount) : Int64Amount - static op_CheckedAddition(Int64Amount, Int64Amount) : Int64Amount - static op_CheckedDivision(Int64Amount, Int64Amount) : Int64Amount - static op_CheckedMultiply(Int64Amount, Int64Amount) : Int64Amount - static op_CheckedSubtraction(Int64Amount, Int64Amount) : Int64Amount - static op_CheckedUnaryNegation(Int64Amount) : Int64Amount - static op_Division(Int64Amount, Int64Amount) : Int64Amount + static From(Int64) : Int64Amount [IPlainValueObject.From] + static MaxValue : Int64Amount [IMinMaxValue.MaxValue] + static MinValue : Int64Amount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : Int64Amount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : Int64Amount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : Int64Amount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out Int64Amount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out Int64Amount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out Int64Amount) : Boolean [IParsable.TryParse] + static op_Addition(Int64Amount, Int64Amount) : Int64Amount [IAdditionOperators.op_Addition] + static op_CheckedAddition(Int64Amount, Int64Amount) : Int64Amount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(Int64Amount, Int64Amount) : Int64Amount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(Int64Amount, Int64Amount) : Int64Amount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(Int64Amount, Int64Amount) : Int64Amount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(Int64Amount) : Int64Amount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(Int64Amount, Int64Amount) : Int64Amount [IDivisionOperators.op_Division] static op_Equality(Int64Amount, Int64Amount) : Boolean - static op_GreaterThan(Int64Amount, Int64Amount) : Boolean - static op_GreaterThanOrEqual(Int64Amount, Int64Amount) : Boolean + static op_GreaterThan(Int64Amount, Int64Amount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(Int64Amount, Int64Amount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(Int64Amount, Int64Amount) : Boolean - static op_LessThan(Int64Amount, Int64Amount) : Boolean - static op_LessThanOrEqual(Int64Amount, Int64Amount) : Boolean - static op_Modulus(Int64Amount, Int64Amount) : Int64Amount - static op_Multiply(Int64Amount, Int64Amount) : Int64Amount - static op_Subtraction(Int64Amount, Int64Amount) : Int64Amount - static op_UnaryNegation(Int64Amount) : Int64Amount - static op_UnaryPlus(Int64Amount) : Int64Amount - extension static Int64AmountExtensions.GetValue(Int64Amount) : Int64 - extension static Int64AmountExtensions.ValueOrNull(Int64Amount?) : Int64? + static op_LessThan(Int64Amount, Int64Amount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(Int64Amount, Int64Amount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(Int64Amount, Int64Amount) : Int64Amount [IModulusOperators.op_Modulus] + static op_Multiply(Int64Amount, Int64Amount) : Int64Amount [IMultiplyOperators.op_Multiply] + static op_Subtraction(Int64Amount, Int64Amount) : Int64Amount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(Int64Amount) : Int64Amount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(Int64Amount) : Int64Amount [IUnaryPlusOperators.op_UnaryPlus] + extension static Int64AmountExtensions.GetValue(Int64Amount) : Int64 [IValueObject.Value] + extension static Int64AmountExtensions.ValueOrNull(Int64Amount?) : Int64? [IValueObject.Value] IntPtrAmount - CompareTo(IntPtrAmount) : Int32 - CompareTo(Object) : Int32 + CompareTo(IntPtrAmount) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(IntPtrAmount) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : IntPtr + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : IntPtr [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3618,49 +3618,49 @@ IntPtrAmount implements IValue implements IValueObject implements IValueObjectMaterializer - nested IntPtrAmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested IntPtrAmountTypeConverter : TypeConverter + nested IntPtrAmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.IntPtrAmountJsonConverter] + nested IntPtrAmountTypeConverter : TypeConverter [IValue.IntPtrAmountTypeConverter] new() - static From(IntPtr) : IntPtrAmount - static MaxValue : IntPtrAmount - static MinValue : IntPtrAmount - static Parse(ReadOnlySpan, IFormatProvider) : IntPtrAmount - static Parse(ReadOnlySpan, IFormatProvider) : IntPtrAmount - static Parse(String, IFormatProvider) : IntPtrAmount - static TryParse(ReadOnlySpan, IFormatProvider, out IntPtrAmount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out IntPtrAmount) : Boolean - static TryParse(String, IFormatProvider, out IntPtrAmount) : Boolean - static op_Addition(IntPtrAmount, IntPtrAmount) : IntPtrAmount - static op_CheckedAddition(IntPtrAmount, IntPtrAmount) : IntPtrAmount - static op_CheckedDivision(IntPtrAmount, IntPtrAmount) : IntPtrAmount - static op_CheckedMultiply(IntPtrAmount, IntPtrAmount) : IntPtrAmount - static op_CheckedSubtraction(IntPtrAmount, IntPtrAmount) : IntPtrAmount - static op_CheckedUnaryNegation(IntPtrAmount) : IntPtrAmount - static op_Division(IntPtrAmount, IntPtrAmount) : IntPtrAmount + static From(IntPtr) : IntPtrAmount [IPlainValueObject.From] + static MaxValue : IntPtrAmount [IMinMaxValue.MaxValue] + static MinValue : IntPtrAmount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : IntPtrAmount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : IntPtrAmount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : IntPtrAmount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out IntPtrAmount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out IntPtrAmount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out IntPtrAmount) : Boolean [IParsable.TryParse] + static op_Addition(IntPtrAmount, IntPtrAmount) : IntPtrAmount [IAdditionOperators.op_Addition] + static op_CheckedAddition(IntPtrAmount, IntPtrAmount) : IntPtrAmount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(IntPtrAmount, IntPtrAmount) : IntPtrAmount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(IntPtrAmount, IntPtrAmount) : IntPtrAmount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(IntPtrAmount, IntPtrAmount) : IntPtrAmount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(IntPtrAmount) : IntPtrAmount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(IntPtrAmount, IntPtrAmount) : IntPtrAmount [IDivisionOperators.op_Division] static op_Equality(IntPtrAmount, IntPtrAmount) : Boolean - static op_GreaterThan(IntPtrAmount, IntPtrAmount) : Boolean - static op_GreaterThanOrEqual(IntPtrAmount, IntPtrAmount) : Boolean + static op_GreaterThan(IntPtrAmount, IntPtrAmount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(IntPtrAmount, IntPtrAmount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(IntPtrAmount, IntPtrAmount) : Boolean - static op_LessThan(IntPtrAmount, IntPtrAmount) : Boolean - static op_LessThanOrEqual(IntPtrAmount, IntPtrAmount) : Boolean - static op_Modulus(IntPtrAmount, IntPtrAmount) : IntPtrAmount - static op_Multiply(IntPtrAmount, IntPtrAmount) : IntPtrAmount - static op_Subtraction(IntPtrAmount, IntPtrAmount) : IntPtrAmount - static op_UnaryNegation(IntPtrAmount) : IntPtrAmount - static op_UnaryPlus(IntPtrAmount) : IntPtrAmount - extension static IntPtrAmountExtensions.GetValue(IntPtrAmount) : IntPtr - extension static IntPtrAmountExtensions.ValueOrNull(IntPtrAmount?) : IntPtr? + static op_LessThan(IntPtrAmount, IntPtrAmount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(IntPtrAmount, IntPtrAmount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(IntPtrAmount, IntPtrAmount) : IntPtrAmount [IModulusOperators.op_Modulus] + static op_Multiply(IntPtrAmount, IntPtrAmount) : IntPtrAmount [IMultiplyOperators.op_Multiply] + static op_Subtraction(IntPtrAmount, IntPtrAmount) : IntPtrAmount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(IntPtrAmount) : IntPtrAmount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(IntPtrAmount) : IntPtrAmount [IUnaryPlusOperators.op_UnaryPlus] + extension static IntPtrAmountExtensions.GetValue(IntPtrAmount) : IntPtr [IValueObject.Value] + extension static IntPtrAmountExtensions.ValueOrNull(IntPtrAmount?) : IntPtr? [IValueObject.Value] InternalAmount (internal) - CompareTo(InternalAmount) : Int32 - CompareTo(Object) : Int32 + CompareTo(InternalAmount) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(InternalAmount) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3690,49 +3690,49 @@ InternalAmount (internal) implements IValue implements IValueObject implements IValueObjectMaterializer - nested InternalAmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested InternalAmountTypeConverter : TypeConverter + nested InternalAmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.InternalAmountJsonConverter] + nested InternalAmountTypeConverter : TypeConverter [IValue.InternalAmountTypeConverter] new() - static From(Int32) : InternalAmount - static MaxValue : InternalAmount - static MinValue : InternalAmount - static Parse(ReadOnlySpan, IFormatProvider) : InternalAmount - static Parse(ReadOnlySpan, IFormatProvider) : InternalAmount - static Parse(String, IFormatProvider) : InternalAmount - static TryParse(ReadOnlySpan, IFormatProvider, out InternalAmount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out InternalAmount) : Boolean - static TryParse(String, IFormatProvider, out InternalAmount) : Boolean - static op_Addition(InternalAmount, InternalAmount) : InternalAmount - static op_CheckedAddition(InternalAmount, InternalAmount) : InternalAmount - static op_CheckedDivision(InternalAmount, InternalAmount) : InternalAmount - static op_CheckedMultiply(InternalAmount, InternalAmount) : InternalAmount - static op_CheckedSubtraction(InternalAmount, InternalAmount) : InternalAmount - static op_CheckedUnaryNegation(InternalAmount) : InternalAmount - static op_Division(InternalAmount, InternalAmount) : InternalAmount + static From(Int32) : InternalAmount [IPlainValueObject.From] + static MaxValue : InternalAmount [IMinMaxValue.MaxValue] + static MinValue : InternalAmount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : InternalAmount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : InternalAmount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : InternalAmount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out InternalAmount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out InternalAmount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out InternalAmount) : Boolean [IParsable.TryParse] + static op_Addition(InternalAmount, InternalAmount) : InternalAmount [IAdditionOperators.op_Addition] + static op_CheckedAddition(InternalAmount, InternalAmount) : InternalAmount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(InternalAmount, InternalAmount) : InternalAmount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(InternalAmount, InternalAmount) : InternalAmount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(InternalAmount, InternalAmount) : InternalAmount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(InternalAmount) : InternalAmount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(InternalAmount, InternalAmount) : InternalAmount [IDivisionOperators.op_Division] static op_Equality(InternalAmount, InternalAmount) : Boolean - static op_GreaterThan(InternalAmount, InternalAmount) : Boolean - static op_GreaterThanOrEqual(InternalAmount, InternalAmount) : Boolean + static op_GreaterThan(InternalAmount, InternalAmount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(InternalAmount, InternalAmount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(InternalAmount, InternalAmount) : Boolean - static op_LessThan(InternalAmount, InternalAmount) : Boolean - static op_LessThanOrEqual(InternalAmount, InternalAmount) : Boolean - static op_Modulus(InternalAmount, InternalAmount) : InternalAmount - static op_Multiply(InternalAmount, InternalAmount) : InternalAmount - static op_Subtraction(InternalAmount, InternalAmount) : InternalAmount - static op_UnaryNegation(InternalAmount) : InternalAmount - static op_UnaryPlus(InternalAmount) : InternalAmount - extension internal static InternalAmountExtensions.GetValue(InternalAmount) : Int32 - extension internal static InternalAmountExtensions.ValueOrNull(InternalAmount?) : Int32? + static op_LessThan(InternalAmount, InternalAmount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(InternalAmount, InternalAmount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(InternalAmount, InternalAmount) : InternalAmount [IModulusOperators.op_Modulus] + static op_Multiply(InternalAmount, InternalAmount) : InternalAmount [IMultiplyOperators.op_Multiply] + static op_Subtraction(InternalAmount, InternalAmount) : InternalAmount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(InternalAmount) : InternalAmount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(InternalAmount) : InternalAmount [IUnaryPlusOperators.op_UnaryPlus] + extension internal static InternalAmountExtensions.GetValue(InternalAmount) : Int32 [IValueObject.Value] + extension internal static InternalAmountExtensions.ValueOrNull(InternalAmount?) : Int32? [IValueObject.Value] Ledger.Entry - CompareTo(Ledger.Entry) : Int32 - CompareTo(Object) : Int32 + CompareTo(Ledger.Entry) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(Ledger.Entry) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int64 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int64 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3762,83 +3762,83 @@ Ledger.Entry implements IValue implements IValueObject implements IValueObjectMaterializer - nested EntryJsonConverter : JsonConverter, IStoredJsonConverterSource - nested EntryTypeConverter : TypeConverter + nested EntryJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.EntryJsonConverter] + nested EntryTypeConverter : TypeConverter [IValue.EntryTypeConverter] new() - static From(Int64) : Ledger.Entry - static MaxValue : Ledger.Entry - static MinValue : Ledger.Entry - static Parse(ReadOnlySpan, IFormatProvider) : Ledger.Entry - static Parse(ReadOnlySpan, IFormatProvider) : Ledger.Entry - static Parse(String, IFormatProvider) : Ledger.Entry - static TryParse(ReadOnlySpan, IFormatProvider, out Ledger.Entry) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out Ledger.Entry) : Boolean - static TryParse(String, IFormatProvider, out Ledger.Entry) : Boolean - static op_Addition(Ledger.Entry, Ledger.Entry) : Ledger.Entry - static op_CheckedAddition(Ledger.Entry, Ledger.Entry) : Ledger.Entry - static op_CheckedDivision(Ledger.Entry, Ledger.Entry) : Ledger.Entry - static op_CheckedMultiply(Ledger.Entry, Ledger.Entry) : Ledger.Entry - static op_CheckedSubtraction(Ledger.Entry, Ledger.Entry) : Ledger.Entry - static op_CheckedUnaryNegation(Ledger.Entry) : Ledger.Entry - static op_Division(Ledger.Entry, Ledger.Entry) : Ledger.Entry + static From(Int64) : Ledger.Entry [IPlainValueObject.From] + static MaxValue : Ledger.Entry [IMinMaxValue.MaxValue] + static MinValue : Ledger.Entry [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : Ledger.Entry [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : Ledger.Entry [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : Ledger.Entry [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out Ledger.Entry) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out Ledger.Entry) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out Ledger.Entry) : Boolean [IParsable.TryParse] + static op_Addition(Ledger.Entry, Ledger.Entry) : Ledger.Entry [IAdditionOperators.op_Addition] + static op_CheckedAddition(Ledger.Entry, Ledger.Entry) : Ledger.Entry [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(Ledger.Entry, Ledger.Entry) : Ledger.Entry [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(Ledger.Entry, Ledger.Entry) : Ledger.Entry [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(Ledger.Entry, Ledger.Entry) : Ledger.Entry [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(Ledger.Entry) : Ledger.Entry [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(Ledger.Entry, Ledger.Entry) : Ledger.Entry [IDivisionOperators.op_Division] static op_Equality(Ledger.Entry, Ledger.Entry) : Boolean - static op_GreaterThan(Ledger.Entry, Ledger.Entry) : Boolean - static op_GreaterThanOrEqual(Ledger.Entry, Ledger.Entry) : Boolean + static op_GreaterThan(Ledger.Entry, Ledger.Entry) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(Ledger.Entry, Ledger.Entry) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(Ledger.Entry, Ledger.Entry) : Boolean - static op_LessThan(Ledger.Entry, Ledger.Entry) : Boolean - static op_LessThanOrEqual(Ledger.Entry, Ledger.Entry) : Boolean - static op_Modulus(Ledger.Entry, Ledger.Entry) : Ledger.Entry - static op_Multiply(Ledger.Entry, Ledger.Entry) : Ledger.Entry - static op_Subtraction(Ledger.Entry, Ledger.Entry) : Ledger.Entry - static op_UnaryNegation(Ledger.Entry) : Ledger.Entry - static op_UnaryPlus(Ledger.Entry) : Ledger.Entry - extension static LedgerEntryExtensions.GetValue(Ledger.Entry) : Int64 - extension static LedgerEntryExtensions.ValueOrNull(Ledger.Entry?) : Int64? + static op_LessThan(Ledger.Entry, Ledger.Entry) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(Ledger.Entry, Ledger.Entry) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(Ledger.Entry, Ledger.Entry) : Ledger.Entry [IModulusOperators.op_Modulus] + static op_Multiply(Ledger.Entry, Ledger.Entry) : Ledger.Entry [IMultiplyOperators.op_Multiply] + static op_Subtraction(Ledger.Entry, Ledger.Entry) : Ledger.Entry [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(Ledger.Entry) : Ledger.Entry [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(Ledger.Entry) : Ledger.Entry [IUnaryPlusOperators.op_UnaryPlus] + extension static LedgerEntryExtensions.GetValue(Ledger.Entry) : Int64 [IValueObject.Value] + extension static LedgerEntryExtensions.ValueOrNull(Ledger.Entry?) : Int64? [IValueObject.Value] LocalOrder.Stage - Match(Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested StageJsonConverter : JsonConverter - nested StageTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : LocalOrder.Stage - static Parse(String, Boolean) : LocalOrder.Stage - static TryParse(String, Boolean, out LocalOrder.Stage) : Boolean - static TryParse(String, out LocalOrder.Stage) : Boolean + nested StageJsonConverter : JsonConverter [IClosedSet.StageJsonConverter] + nested StageTypeConverter : TypeConverter [IClosedSet.StageTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : LocalOrder.Stage [IClosedSet.Parse] + static Parse(String, Boolean) : LocalOrder.Stage [IClosedSet.Parse] + static TryParse(String, Boolean, out LocalOrder.Stage) : Boolean [IClosedSet.TryParse] + static TryParse(String, out LocalOrder.Stage) : Boolean [IClosedSet.TryParse] LocalStatus - Match(Func, Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested LocalStatusJsonConverter : JsonConverter - nested LocalStatusTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : LocalStatus - static Parse(String, Boolean) : LocalStatus - static TryParse(String, Boolean, out LocalStatus) : Boolean - static TryParse(String, out LocalStatus) : Boolean + nested LocalStatusJsonConverter : JsonConverter [IClosedSet.LocalStatusJsonConverter] + nested LocalStatusTypeConverter : TypeConverter [IClosedSet.LocalStatusTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : LocalStatus [IClosedSet.Parse] + static Parse(String, Boolean) : LocalStatus [IClosedSet.Parse] + static TryParse(String, Boolean, out LocalStatus) : Boolean [IClosedSet.TryParse] + static TryParse(String, out LocalStatus) : Boolean [IClosedSet.TryParse] MaskedOverALibraryRecord $() : MaskedOverALibraryRecord - CompareTo(MaskedOverALibraryRecord) : Int32 - CompareTo(Object) : Int32 + CompareTo(MaskedOverALibraryRecord) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(MaskedOverALibraryRecord) : Boolean Equals(Object) : Boolean Equals(ProbeMaskingRecord) : Boolean GetHashCode() : Int32 - Value : String + Value : String [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3857,30 +3857,30 @@ MaskedOverALibraryRecord implements IValue implements IValueObject implements IValueObjectMaterializer - nested MaskedOverALibraryRecordJsonConverter : JsonConverter, IStoredJsonConverterSource - nested MaskedOverALibraryRecordTypeConverter : TypeConverter - static From(String) : MaskedOverALibraryRecord - static Parse(ReadOnlySpan, IFormatProvider) : MaskedOverALibraryRecord - static Parse(String, IFormatProvider) : MaskedOverALibraryRecord - static TryParse(ReadOnlySpan, IFormatProvider, out MaskedOverALibraryRecord) : Boolean - static TryParse(String, IFormatProvider, out MaskedOverALibraryRecord) : Boolean + nested MaskedOverALibraryRecordJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.MaskedOverALibraryRecordJsonConverter] + nested MaskedOverALibraryRecordTypeConverter : TypeConverter [IValue.MaskedOverALibraryRecordTypeConverter] + static From(String) : MaskedOverALibraryRecord [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : MaskedOverALibraryRecord [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : MaskedOverALibraryRecord [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out MaskedOverALibraryRecord) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out MaskedOverALibraryRecord) : Boolean [IParsable.TryParse] static op_Equality(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean - static op_GreaterThan(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean - static op_GreaterThanOrEqual(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean + static op_GreaterThan(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean - static op_LessThan(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean - static op_LessThanOrEqual(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean - extension static MaskedOverALibraryRecordExtensions.GetValue(MaskedOverALibraryRecord) : String - extension static MaskedOverALibraryRecordExtensions.ValueOrNull(MaskedOverALibraryRecord) : String + static op_LessThan(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(MaskedOverALibraryRecord, MaskedOverALibraryRecord) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static MaskedOverALibraryRecordExtensions.GetValue(MaskedOverALibraryRecord) : String [IValueObject.Value] + extension static MaskedOverALibraryRecordExtensions.ValueOrNull(MaskedOverALibraryRecord) : String [IValueObject.Value] MaskedOverALocalRecord $() : MaskedOverALocalRecord - CompareTo(MaskedOverALocalRecord) : Int32 - CompareTo(Object) : Int32 + CompareTo(MaskedOverALocalRecord) : Int32 [IComparable.CompareTo] + CompareTo(Object) : Int32 [IComparable.CompareTo] Equals(LocalMaskingRecord) : Boolean Equals(MaskedOverALocalRecord) : Boolean Equals(Object) : Boolean GetHashCode() : Int32 - Value : String + Value : String [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3899,51 +3899,51 @@ MaskedOverALocalRecord implements IValue implements IValueObject implements IValueObjectMaterializer - nested MaskedOverALocalRecordJsonConverter : JsonConverter, IStoredJsonConverterSource - nested MaskedOverALocalRecordTypeConverter : TypeConverter - static From(String) : MaskedOverALocalRecord - static Parse(ReadOnlySpan, IFormatProvider) : MaskedOverALocalRecord - static Parse(String, IFormatProvider) : MaskedOverALocalRecord - static TryParse(ReadOnlySpan, IFormatProvider, out MaskedOverALocalRecord) : Boolean - static TryParse(String, IFormatProvider, out MaskedOverALocalRecord) : Boolean + nested MaskedOverALocalRecordJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.MaskedOverALocalRecordJsonConverter] + nested MaskedOverALocalRecordTypeConverter : TypeConverter [IValue.MaskedOverALocalRecordTypeConverter] + static From(String) : MaskedOverALocalRecord [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : MaskedOverALocalRecord [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : MaskedOverALocalRecord [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out MaskedOverALocalRecord) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out MaskedOverALocalRecord) : Boolean [IParsable.TryParse] static op_Equality(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean - static op_GreaterThan(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean - static op_GreaterThanOrEqual(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean + static op_GreaterThan(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean - static op_LessThan(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean - static op_LessThanOrEqual(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean - extension static MaskedOverALocalRecordExtensions.GetValue(MaskedOverALocalRecord) : String - extension static MaskedOverALocalRecordExtensions.ValueOrNull(MaskedOverALocalRecord) : String + static op_LessThan(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(MaskedOverALocalRecord, MaskedOverALocalRecord) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static MaskedOverALocalRecordExtensions.GetValue(MaskedOverALocalRecord) : String [IValueObject.Value] + extension static MaskedOverALocalRecordExtensions.ValueOrNull(MaskedOverALocalRecord) : String [IValueObject.Value] MaskedSet - Match(Func, Func) : TResult - Name : String - QualifiedName : String + Match(Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested MaskedSetJsonConverter : JsonConverter - nested MaskedSetTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : MaskedSet - static Parse(String, Boolean) : MaskedSet - static TryParse(String, Boolean, out MaskedSet) : Boolean - static TryParse(String, out MaskedSet) : Boolean + nested MaskedSetJsonConverter : JsonConverter [IClosedSet.MaskedSetJsonConverter] + nested MaskedSetTypeConverter : TypeConverter [IClosedSet.MaskedSetTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : MaskedSet [IClosedSet.Parse] + static Parse(String, Boolean) : MaskedSet [IClosedSet.Parse] + static TryParse(String, Boolean, out MaskedSet) : Boolean [IClosedSet.TryParse] + static TryParse(String, out MaskedSet) : Boolean [IClosedSet.TryParse] ObjectCompareToOverloaded - CompareTo(Object) : Int32 - CompareTo(ObjectCompareToOverloaded) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ObjectCompareToOverloaded) : Int32 [IComparable.CompareTo] CompareTo(in Object) : Int32 CompareTo(Object) : Int32 Equals(Object) : Boolean Equals(ObjectCompareToOverloaded) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -3965,40 +3965,40 @@ ObjectCompareToOverloaded implements IValue implements IValueObject implements IValueObjectMaterializer - nested ObjectCompareToOverloadedJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ObjectCompareToOverloadedTypeConverter : TypeConverter + nested ObjectCompareToOverloadedJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ObjectCompareToOverloadedJsonConverter] + nested ObjectCompareToOverloadedTypeConverter : TypeConverter [IValue.ObjectCompareToOverloadedTypeConverter] new() - static From(Int32) : ObjectCompareToOverloaded - static MaxValue : ObjectCompareToOverloaded - static MinValue : ObjectCompareToOverloaded - static Parse(ReadOnlySpan, IFormatProvider) : ObjectCompareToOverloaded - static Parse(ReadOnlySpan, IFormatProvider) : ObjectCompareToOverloaded - static Parse(String, IFormatProvider) : ObjectCompareToOverloaded - static TryParse(ReadOnlySpan, IFormatProvider, out ObjectCompareToOverloaded) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ObjectCompareToOverloaded) : Boolean - static TryParse(String, IFormatProvider, out ObjectCompareToOverloaded) : Boolean + static From(Int32) : ObjectCompareToOverloaded [IPlainValueObject.From] + static MaxValue : ObjectCompareToOverloaded [IMinMaxValue.MaxValue] + static MinValue : ObjectCompareToOverloaded [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ObjectCompareToOverloaded [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ObjectCompareToOverloaded [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ObjectCompareToOverloaded [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ObjectCompareToOverloaded) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ObjectCompareToOverloaded) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ObjectCompareToOverloaded) : Boolean [IParsable.TryParse] static op_Equality(ObjectCompareToOverloaded, ObjectCompareToOverloaded) : Boolean - static op_GreaterThan(ObjectCompareToOverloaded, ObjectCompareToOverloaded) : Boolean - static op_GreaterThanOrEqual(ObjectCompareToOverloaded, ObjectCompareToOverloaded) : Boolean + static op_GreaterThan(ObjectCompareToOverloaded, ObjectCompareToOverloaded) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ObjectCompareToOverloaded, ObjectCompareToOverloaded) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ObjectCompareToOverloaded, ObjectCompareToOverloaded) : Boolean - static op_LessThan(ObjectCompareToOverloaded, ObjectCompareToOverloaded) : Boolean - static op_LessThanOrEqual(ObjectCompareToOverloaded, ObjectCompareToOverloaded) : Boolean - extension static ObjectCompareToOverloadedExtensions.GetValue(ObjectCompareToOverloaded) : Int32 - extension static ObjectCompareToOverloadedExtensions.ValueOrNull(ObjectCompareToOverloaded?) : Int32? + static op_LessThan(ObjectCompareToOverloaded, ObjectCompareToOverloaded) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ObjectCompareToOverloaded, ObjectCompareToOverloaded) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ObjectCompareToOverloadedExtensions.GetValue(ObjectCompareToOverloaded) : Int32 [IValueObject.Value] + extension static ObjectCompareToOverloadedExtensions.ValueOrNull(ObjectCompareToOverloaded?) : Int32? [IValueObject.Value] OverABetweenExplicitEqualityRecord $() : OverABetweenExplicitEqualityRecord - CompareTo(Object) : Int32 - CompareTo(OverABetweenExplicitEqualityRecord) : Int32 - Equals(LocalEqualityFreeRecord) : Boolean + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverABetweenExplicitEqualityRecord) : Int32 [IComparable.CompareTo] + Equals(LocalEqualityFreeRecord) : Boolean [IEquatable.Equals] Equals(LocalReimplementingBetweenRecord) : Boolean Equals(Object) : Boolean Equals(OverABetweenExplicitEqualityRecord) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4024,39 +4024,39 @@ OverABetweenExplicitEqualityRecord implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverABetweenExplicitEqualityRecordJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverABetweenExplicitEqualityRecordTypeConverter : TypeConverter - static From(Int32) : OverABetweenExplicitEqualityRecord - static MaxValue : OverABetweenExplicitEqualityRecord - static MinValue : OverABetweenExplicitEqualityRecord - static Parse(ReadOnlySpan, IFormatProvider) : OverABetweenExplicitEqualityRecord - static Parse(ReadOnlySpan, IFormatProvider) : OverABetweenExplicitEqualityRecord - static Parse(String, IFormatProvider) : OverABetweenExplicitEqualityRecord - static TryParse(ReadOnlySpan, IFormatProvider, out OverABetweenExplicitEqualityRecord) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out OverABetweenExplicitEqualityRecord) : Boolean - static TryParse(String, IFormatProvider, out OverABetweenExplicitEqualityRecord) : Boolean + nested OverABetweenExplicitEqualityRecordJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverABetweenExplicitEqualityRecordJsonConverter] + nested OverABetweenExplicitEqualityRecordTypeConverter : TypeConverter [IValue.OverABetweenExplicitEqualityRecordTypeConverter] + static From(Int32) : OverABetweenExplicitEqualityRecord [IPlainValueObject.From] + static MaxValue : OverABetweenExplicitEqualityRecord [IMinMaxValue.MaxValue] + static MinValue : OverABetweenExplicitEqualityRecord [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : OverABetweenExplicitEqualityRecord [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : OverABetweenExplicitEqualityRecord [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : OverABetweenExplicitEqualityRecord [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverABetweenExplicitEqualityRecord) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverABetweenExplicitEqualityRecord) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverABetweenExplicitEqualityRecord) : Boolean [IParsable.TryParse] static op_Equality(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean - static op_GreaterThan(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean - static op_GreaterThanOrEqual(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean + static op_GreaterThan(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean - static op_LessThan(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean - static op_LessThanOrEqual(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean - extension static OverABetweenExplicitEqualityRecordExtensions.GetValue(OverABetweenExplicitEqualityRecord) : Int32 - extension static OverABetweenExplicitEqualityRecordExtensions.ValueOrNull(OverABetweenExplicitEqualityRecord) : Int32? + static op_LessThan(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverABetweenExplicitEqualityRecord, OverABetweenExplicitEqualityRecord) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverABetweenExplicitEqualityRecordExtensions.GetValue(OverABetweenExplicitEqualityRecord) : Int32 [IValueObject.Value] + extension static OverABetweenExplicitEqualityRecordExtensions.ValueOrNull(OverABetweenExplicitEqualityRecord) : Int32? [IValueObject.Value] OverADeeperExplicitEqualityRecord $() : OverADeeperExplicitEqualityRecord - CompareTo(Object) : Int32 - CompareTo(OverADeeperExplicitEqualityRecord) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverADeeperExplicitEqualityRecord) : Int32 [IComparable.CompareTo] Equals(LocalBetweenRecord) : Boolean - Equals(LocalExplicitEqualityRecord) : Boolean + Equals(LocalExplicitEqualityRecord) : Boolean [IEquatable.Equals] Equals(Object) : Boolean Equals(OverADeeperExplicitEqualityRecord) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4082,38 +4082,38 @@ OverADeeperExplicitEqualityRecord implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverADeeperExplicitEqualityRecordJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverADeeperExplicitEqualityRecordTypeConverter : TypeConverter - static From(Int32) : OverADeeperExplicitEqualityRecord - static MaxValue : OverADeeperExplicitEqualityRecord - static MinValue : OverADeeperExplicitEqualityRecord - static Parse(ReadOnlySpan, IFormatProvider) : OverADeeperExplicitEqualityRecord - static Parse(ReadOnlySpan, IFormatProvider) : OverADeeperExplicitEqualityRecord - static Parse(String, IFormatProvider) : OverADeeperExplicitEqualityRecord - static TryParse(ReadOnlySpan, IFormatProvider, out OverADeeperExplicitEqualityRecord) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out OverADeeperExplicitEqualityRecord) : Boolean - static TryParse(String, IFormatProvider, out OverADeeperExplicitEqualityRecord) : Boolean + nested OverADeeperExplicitEqualityRecordJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverADeeperExplicitEqualityRecordJsonConverter] + nested OverADeeperExplicitEqualityRecordTypeConverter : TypeConverter [IValue.OverADeeperExplicitEqualityRecordTypeConverter] + static From(Int32) : OverADeeperExplicitEqualityRecord [IPlainValueObject.From] + static MaxValue : OverADeeperExplicitEqualityRecord [IMinMaxValue.MaxValue] + static MinValue : OverADeeperExplicitEqualityRecord [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : OverADeeperExplicitEqualityRecord [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : OverADeeperExplicitEqualityRecord [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : OverADeeperExplicitEqualityRecord [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverADeeperExplicitEqualityRecord) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverADeeperExplicitEqualityRecord) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverADeeperExplicitEqualityRecord) : Boolean [IParsable.TryParse] static op_Equality(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean - static op_GreaterThan(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean - static op_GreaterThanOrEqual(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean + static op_GreaterThan(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean - static op_LessThan(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean - static op_LessThanOrEqual(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean - extension static OverADeeperExplicitEqualityRecordExtensions.GetValue(OverADeeperExplicitEqualityRecord) : Int32 - extension static OverADeeperExplicitEqualityRecordExtensions.ValueOrNull(OverADeeperExplicitEqualityRecord) : Int32? + static op_LessThan(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverADeeperExplicitEqualityRecord, OverADeeperExplicitEqualityRecord) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverADeeperExplicitEqualityRecordExtensions.GetValue(OverADeeperExplicitEqualityRecord) : Int32 [IValueObject.Value] + extension static OverADeeperExplicitEqualityRecordExtensions.ValueOrNull(OverADeeperExplicitEqualityRecord) : Int32? [IValueObject.Value] OverALibraryOverloadingBase $() : OverALibraryOverloadingBase - CompareTo(Object) : Int32 - CompareTo(OverALibraryOverloadingBase) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverALibraryOverloadingBase) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(OverALibraryOverloadingBase) : Boolean Equals(ProbeOverloadingRecord) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4137,38 +4137,38 @@ OverALibraryOverloadingBase implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverALibraryOverloadingBaseJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverALibraryOverloadingBaseTypeConverter : TypeConverter - static From(Int32) : OverALibraryOverloadingBase - static MaxValue : OverALibraryOverloadingBase - static MinValue : OverALibraryOverloadingBase - static Parse(ReadOnlySpan, IFormatProvider) : OverALibraryOverloadingBase - static Parse(ReadOnlySpan, IFormatProvider) : OverALibraryOverloadingBase - static Parse(String, IFormatProvider) : OverALibraryOverloadingBase - static TryParse(ReadOnlySpan, IFormatProvider, out OverALibraryOverloadingBase) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out OverALibraryOverloadingBase) : Boolean - static TryParse(String, IFormatProvider, out OverALibraryOverloadingBase) : Boolean + nested OverALibraryOverloadingBaseJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverALibraryOverloadingBaseJsonConverter] + nested OverALibraryOverloadingBaseTypeConverter : TypeConverter [IValue.OverALibraryOverloadingBaseTypeConverter] + static From(Int32) : OverALibraryOverloadingBase [IPlainValueObject.From] + static MaxValue : OverALibraryOverloadingBase [IMinMaxValue.MaxValue] + static MinValue : OverALibraryOverloadingBase [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : OverALibraryOverloadingBase [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : OverALibraryOverloadingBase [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : OverALibraryOverloadingBase [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverALibraryOverloadingBase) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverALibraryOverloadingBase) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverALibraryOverloadingBase) : Boolean [IParsable.TryParse] static op_Equality(OverALibraryOverloadingBase, OverALibraryOverloadingBase) : Boolean - static op_GreaterThan(OverALibraryOverloadingBase, OverALibraryOverloadingBase) : Boolean - static op_GreaterThanOrEqual(OverALibraryOverloadingBase, OverALibraryOverloadingBase) : Boolean + static op_GreaterThan(OverALibraryOverloadingBase, OverALibraryOverloadingBase) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverALibraryOverloadingBase, OverALibraryOverloadingBase) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverALibraryOverloadingBase, OverALibraryOverloadingBase) : Boolean - static op_LessThan(OverALibraryOverloadingBase, OverALibraryOverloadingBase) : Boolean - static op_LessThanOrEqual(OverALibraryOverloadingBase, OverALibraryOverloadingBase) : Boolean - extension static OverALibraryOverloadingBaseExtensions.GetValue(OverALibraryOverloadingBase) : Int32 - extension static OverALibraryOverloadingBaseExtensions.ValueOrNull(OverALibraryOverloadingBase) : Int32? + static op_LessThan(OverALibraryOverloadingBase, OverALibraryOverloadingBase) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverALibraryOverloadingBase, OverALibraryOverloadingBase) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverALibraryOverloadingBaseExtensions.GetValue(OverALibraryOverloadingBase) : Int32 [IValueObject.Value] + extension static OverALibraryOverloadingBaseExtensions.ValueOrNull(OverALibraryOverloadingBase) : Int32? [IValueObject.Value] OverALibraryRecord $() : OverALibraryRecord - CompareTo(Object) : Int32 - CompareTo(OverALibraryRecord) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverALibraryRecord) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(OverALibraryRecord) : Boolean Equals(ProbeRecordBase) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4192,38 +4192,38 @@ OverALibraryRecord implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverALibraryRecordJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverALibraryRecordTypeConverter : TypeConverter - static From(Int32) : OverALibraryRecord - static MaxValue : OverALibraryRecord - static MinValue : OverALibraryRecord - static Parse(ReadOnlySpan, IFormatProvider) : OverALibraryRecord - static Parse(ReadOnlySpan, IFormatProvider) : OverALibraryRecord - static Parse(String, IFormatProvider) : OverALibraryRecord - static TryParse(ReadOnlySpan, IFormatProvider, out OverALibraryRecord) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out OverALibraryRecord) : Boolean - static TryParse(String, IFormatProvider, out OverALibraryRecord) : Boolean + nested OverALibraryRecordJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverALibraryRecordJsonConverter] + nested OverALibraryRecordTypeConverter : TypeConverter [IValue.OverALibraryRecordTypeConverter] + static From(Int32) : OverALibraryRecord [IPlainValueObject.From] + static MaxValue : OverALibraryRecord [IMinMaxValue.MaxValue] + static MinValue : OverALibraryRecord [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : OverALibraryRecord [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : OverALibraryRecord [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : OverALibraryRecord [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverALibraryRecord) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverALibraryRecord) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverALibraryRecord) : Boolean [IParsable.TryParse] static op_Equality(OverALibraryRecord, OverALibraryRecord) : Boolean - static op_GreaterThan(OverALibraryRecord, OverALibraryRecord) : Boolean - static op_GreaterThanOrEqual(OverALibraryRecord, OverALibraryRecord) : Boolean + static op_GreaterThan(OverALibraryRecord, OverALibraryRecord) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverALibraryRecord, OverALibraryRecord) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverALibraryRecord, OverALibraryRecord) : Boolean - static op_LessThan(OverALibraryRecord, OverALibraryRecord) : Boolean - static op_LessThanOrEqual(OverALibraryRecord, OverALibraryRecord) : Boolean - extension static OverALibraryRecordExtensions.GetValue(OverALibraryRecord) : Int32 - extension static OverALibraryRecordExtensions.ValueOrNull(OverALibraryRecord) : Int32? + static op_LessThan(OverALibraryRecord, OverALibraryRecord) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverALibraryRecord, OverALibraryRecord) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverALibraryRecordExtensions.GetValue(OverALibraryRecord) : Int32 [IValueObject.Value] + extension static OverALibraryRecordExtensions.ValueOrNull(OverALibraryRecord) : Int32? [IValueObject.Value] OverAReferenceEqualityRecord $() : OverAReferenceEqualityRecord - CompareTo(Object) : Int32 - CompareTo(OverAReferenceEqualityRecord) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverAReferenceEqualityRecord) : Int32 [IComparable.CompareTo] Equals(LocalReferenceEqualityRecord) : Boolean Equals(Object) : Boolean Equals(OverAReferenceEqualityRecord) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4247,35 +4247,35 @@ OverAReferenceEqualityRecord implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverAReferenceEqualityRecordJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverAReferenceEqualityRecordTypeConverter : TypeConverter - static From(Int32) : OverAReferenceEqualityRecord - static MaxValue : OverAReferenceEqualityRecord - static MinValue : OverAReferenceEqualityRecord - static Parse(ReadOnlySpan, IFormatProvider) : OverAReferenceEqualityRecord - static Parse(ReadOnlySpan, IFormatProvider) : OverAReferenceEqualityRecord - static Parse(String, IFormatProvider) : OverAReferenceEqualityRecord - static TryParse(ReadOnlySpan, IFormatProvider, out OverAReferenceEqualityRecord) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out OverAReferenceEqualityRecord) : Boolean - static TryParse(String, IFormatProvider, out OverAReferenceEqualityRecord) : Boolean + nested OverAReferenceEqualityRecordJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverAReferenceEqualityRecordJsonConverter] + nested OverAReferenceEqualityRecordTypeConverter : TypeConverter [IValue.OverAReferenceEqualityRecordTypeConverter] + static From(Int32) : OverAReferenceEqualityRecord [IPlainValueObject.From] + static MaxValue : OverAReferenceEqualityRecord [IMinMaxValue.MaxValue] + static MinValue : OverAReferenceEqualityRecord [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : OverAReferenceEqualityRecord [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : OverAReferenceEqualityRecord [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : OverAReferenceEqualityRecord [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverAReferenceEqualityRecord) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverAReferenceEqualityRecord) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverAReferenceEqualityRecord) : Boolean [IParsable.TryParse] static op_Equality(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean - static op_GreaterThan(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean - static op_GreaterThanOrEqual(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean + static op_GreaterThan(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean - static op_LessThan(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean - static op_LessThanOrEqual(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean - extension static OverAReferenceEqualityRecordExtensions.GetValue(OverAReferenceEqualityRecord) : Int32 - extension static OverAReferenceEqualityRecordExtensions.ValueOrNull(OverAReferenceEqualityRecord) : Int32? + static op_LessThan(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverAReferenceEqualityRecord, OverAReferenceEqualityRecord) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverAReferenceEqualityRecordExtensions.GetValue(OverAReferenceEqualityRecord) : Int32 [IValueObject.Value] + extension static OverAReferenceEqualityRecordExtensions.ValueOrNull(OverAReferenceEqualityRecord) : Int32? [IValueObject.Value] OverAccess - CompareTo(Object) : Int32 - CompareTo(OverAccess) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverAccess) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(OverAccess) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : ProbeAccess + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : ProbeAccess [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4293,33 +4293,33 @@ OverAccess implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverAccessJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverAccessTypeConverter : TypeConverter + nested OverAccessJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverAccessJsonConverter] + nested OverAccessTypeConverter : TypeConverter [IValue.OverAccessTypeConverter] new() - static From(ProbeAccess) : OverAccess - static Parse(String, IFormatProvider) : OverAccess - static TryParse(String, IFormatProvider, out OverAccess) : Boolean + static From(ProbeAccess) : OverAccess [IPlainValueObject.From] + static Parse(String, IFormatProvider) : OverAccess [IParsable.Parse] + static TryParse(String, IFormatProvider, out OverAccess) : Boolean [IParsable.TryParse] static op_Equality(OverAccess, OverAccess) : Boolean - static op_GreaterThan(OverAccess, OverAccess) : Boolean - static op_GreaterThanOrEqual(OverAccess, OverAccess) : Boolean + static op_GreaterThan(OverAccess, OverAccess) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverAccess, OverAccess) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverAccess, OverAccess) : Boolean - static op_LessThan(OverAccess, OverAccess) : Boolean - static op_LessThanOrEqual(OverAccess, OverAccess) : Boolean - extension static OverAccessExtensions.GetValue(OverAccess) : ProbeAccess - extension static OverAccessExtensions.ValueOrNull(OverAccess?) : ProbeAccess? + static op_LessThan(OverAccess, OverAccess) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverAccess, OverAccess) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverAccessExtensions.GetValue(OverAccess) : ProbeAccess [IValueObject.Value] + extension static OverAccessExtensions.ValueOrNull(OverAccess?) : ProbeAccess? [IValueObject.Value] OverAnExplicitEqualityRecord $() : OverAnExplicitEqualityRecord - CompareTo(Object) : Int32 - CompareTo(OverAnExplicitEqualityRecord) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverAnExplicitEqualityRecord) : Int32 [IComparable.CompareTo] Equals(LocalExplicitEqualityRecord) : Boolean Equals(Object) : Boolean Equals(OverAnExplicitEqualityRecord) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4343,38 +4343,38 @@ OverAnExplicitEqualityRecord implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverAnExplicitEqualityRecordJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverAnExplicitEqualityRecordTypeConverter : TypeConverter - static From(Int32) : OverAnExplicitEqualityRecord - static MaxValue : OverAnExplicitEqualityRecord - static MinValue : OverAnExplicitEqualityRecord - static Parse(ReadOnlySpan, IFormatProvider) : OverAnExplicitEqualityRecord - static Parse(ReadOnlySpan, IFormatProvider) : OverAnExplicitEqualityRecord - static Parse(String, IFormatProvider) : OverAnExplicitEqualityRecord - static TryParse(ReadOnlySpan, IFormatProvider, out OverAnExplicitEqualityRecord) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out OverAnExplicitEqualityRecord) : Boolean - static TryParse(String, IFormatProvider, out OverAnExplicitEqualityRecord) : Boolean + nested OverAnExplicitEqualityRecordJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverAnExplicitEqualityRecordJsonConverter] + nested OverAnExplicitEqualityRecordTypeConverter : TypeConverter [IValue.OverAnExplicitEqualityRecordTypeConverter] + static From(Int32) : OverAnExplicitEqualityRecord [IPlainValueObject.From] + static MaxValue : OverAnExplicitEqualityRecord [IMinMaxValue.MaxValue] + static MinValue : OverAnExplicitEqualityRecord [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : OverAnExplicitEqualityRecord [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : OverAnExplicitEqualityRecord [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : OverAnExplicitEqualityRecord [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverAnExplicitEqualityRecord) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverAnExplicitEqualityRecord) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverAnExplicitEqualityRecord) : Boolean [IParsable.TryParse] static op_Equality(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean - static op_GreaterThan(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean - static op_GreaterThanOrEqual(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean + static op_GreaterThan(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean - static op_LessThan(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean - static op_LessThanOrEqual(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean - extension static OverAnExplicitEqualityRecordExtensions.GetValue(OverAnExplicitEqualityRecord) : Int32 - extension static OverAnExplicitEqualityRecordExtensions.ValueOrNull(OverAnExplicitEqualityRecord) : Int32? + static op_LessThan(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverAnExplicitEqualityRecord, OverAnExplicitEqualityRecord) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverAnExplicitEqualityRecordExtensions.GetValue(OverAnExplicitEqualityRecord) : Int32 [IValueObject.Value] + extension static OverAnExplicitEqualityRecordExtensions.ValueOrNull(OverAnExplicitEqualityRecord) : Int32? [IValueObject.Value] OverAnIdentityRecord $() : OverAnIdentityRecord - CompareTo(Object) : Int32 - CompareTo(OverAnIdentityRecord) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverAnIdentityRecord) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(OverAnIdentityRecord) : Boolean Equals(ProbeIdentityRecord) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4398,38 +4398,38 @@ OverAnIdentityRecord implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverAnIdentityRecordJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverAnIdentityRecordTypeConverter : TypeConverter - static From(Int32) : OverAnIdentityRecord - static MaxValue : OverAnIdentityRecord - static MinValue : OverAnIdentityRecord - static Parse(ReadOnlySpan, IFormatProvider) : OverAnIdentityRecord - static Parse(ReadOnlySpan, IFormatProvider) : OverAnIdentityRecord - static Parse(String, IFormatProvider) : OverAnIdentityRecord - static TryParse(ReadOnlySpan, IFormatProvider, out OverAnIdentityRecord) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out OverAnIdentityRecord) : Boolean - static TryParse(String, IFormatProvider, out OverAnIdentityRecord) : Boolean + nested OverAnIdentityRecordJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverAnIdentityRecordJsonConverter] + nested OverAnIdentityRecordTypeConverter : TypeConverter [IValue.OverAnIdentityRecordTypeConverter] + static From(Int32) : OverAnIdentityRecord [IPlainValueObject.From] + static MaxValue : OverAnIdentityRecord [IMinMaxValue.MaxValue] + static MinValue : OverAnIdentityRecord [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : OverAnIdentityRecord [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : OverAnIdentityRecord [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : OverAnIdentityRecord [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverAnIdentityRecord) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverAnIdentityRecord) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverAnIdentityRecord) : Boolean [IParsable.TryParse] static op_Equality(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean - static op_GreaterThan(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean - static op_GreaterThanOrEqual(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean + static op_GreaterThan(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean - static op_LessThan(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean - static op_LessThanOrEqual(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean - extension static OverAnIdentityRecordExtensions.GetValue(OverAnIdentityRecord) : Int32 - extension static OverAnIdentityRecordExtensions.ValueOrNull(OverAnIdentityRecord) : Int32? + static op_LessThan(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverAnIdentityRecord, OverAnIdentityRecord) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverAnIdentityRecordExtensions.GetValue(OverAnIdentityRecord) : Int32 [IValueObject.Value] + extension static OverAnIdentityRecordExtensions.ValueOrNull(OverAnIdentityRecord) : Int32? [IValueObject.Value] OverAnOverloadingBase $() : OverAnOverloadingBase - CompareTo(Object) : Int32 - CompareTo(OverAnOverloadingBase) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverAnOverloadingBase) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(OverAnOverloadingBase) : Boolean Equals(OverloadingBase) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4453,36 +4453,36 @@ OverAnOverloadingBase implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverAnOverloadingBaseJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverAnOverloadingBaseTypeConverter : TypeConverter - static From(Int32) : OverAnOverloadingBase - static MaxValue : OverAnOverloadingBase - static MinValue : OverAnOverloadingBase - static Parse(ReadOnlySpan, IFormatProvider) : OverAnOverloadingBase - static Parse(ReadOnlySpan, IFormatProvider) : OverAnOverloadingBase - static Parse(String, IFormatProvider) : OverAnOverloadingBase - static TryParse(ReadOnlySpan, IFormatProvider, out OverAnOverloadingBase) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out OverAnOverloadingBase) : Boolean - static TryParse(String, IFormatProvider, out OverAnOverloadingBase) : Boolean + nested OverAnOverloadingBaseJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverAnOverloadingBaseJsonConverter] + nested OverAnOverloadingBaseTypeConverter : TypeConverter [IValue.OverAnOverloadingBaseTypeConverter] + static From(Int32) : OverAnOverloadingBase [IPlainValueObject.From] + static MaxValue : OverAnOverloadingBase [IMinMaxValue.MaxValue] + static MinValue : OverAnOverloadingBase [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : OverAnOverloadingBase [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : OverAnOverloadingBase [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : OverAnOverloadingBase [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverAnOverloadingBase) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverAnOverloadingBase) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverAnOverloadingBase) : Boolean [IParsable.TryParse] static op_Equality(OverAnOverloadingBase, OverAnOverloadingBase) : Boolean - static op_GreaterThan(OverAnOverloadingBase, OverAnOverloadingBase) : Boolean - static op_GreaterThanOrEqual(OverAnOverloadingBase, OverAnOverloadingBase) : Boolean + static op_GreaterThan(OverAnOverloadingBase, OverAnOverloadingBase) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverAnOverloadingBase, OverAnOverloadingBase) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverAnOverloadingBase, OverAnOverloadingBase) : Boolean - static op_LessThan(OverAnOverloadingBase, OverAnOverloadingBase) : Boolean - static op_LessThanOrEqual(OverAnOverloadingBase, OverAnOverloadingBase) : Boolean - extension static OverAnOverloadingBaseExtensions.GetValue(OverAnOverloadingBase) : Int32 - extension static OverAnOverloadingBaseExtensions.ValueOrNull(OverAnOverloadingBase) : Int32? + static op_LessThan(OverAnOverloadingBase, OverAnOverloadingBase) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverAnOverloadingBase, OverAnOverloadingBase) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverAnOverloadingBaseExtensions.GetValue(OverAnOverloadingBase) : Int32 [IValueObject.Value] + extension static OverAnOverloadingBaseExtensions.ValueOrNull(OverAnOverloadingBase) : Int32? [IValueObject.Value] OverByte - CompareTo(Object) : Int32 - CompareTo(OverByte) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverByte) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(OverByte) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Byte + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Byte [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4504,37 +4504,37 @@ OverByte implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverByteJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverByteTypeConverter : TypeConverter + nested OverByteJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverByteJsonConverter] + nested OverByteTypeConverter : TypeConverter [IValue.OverByteTypeConverter] new() - static From(Byte) : OverByte - static MaxValue : OverByte - static MinValue : OverByte - static Parse(ReadOnlySpan, IFormatProvider) : OverByte - static Parse(ReadOnlySpan, IFormatProvider) : OverByte - static Parse(String, IFormatProvider) : OverByte - static TryParse(ReadOnlySpan, IFormatProvider, out OverByte) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out OverByte) : Boolean - static TryParse(String, IFormatProvider, out OverByte) : Boolean + static From(Byte) : OverByte [IPlainValueObject.From] + static MaxValue : OverByte [IMinMaxValue.MaxValue] + static MinValue : OverByte [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : OverByte [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : OverByte [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : OverByte [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverByte) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverByte) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverByte) : Boolean [IParsable.TryParse] static op_Equality(OverByte, OverByte) : Boolean - static op_GreaterThan(OverByte, OverByte) : Boolean - static op_GreaterThanOrEqual(OverByte, OverByte) : Boolean + static op_GreaterThan(OverByte, OverByte) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverByte, OverByte) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverByte, OverByte) : Boolean - static op_LessThan(OverByte, OverByte) : Boolean - static op_LessThanOrEqual(OverByte, OverByte) : Boolean - extension static OverByteExtensions.GetValue(OverByte) : Byte - extension static OverByteExtensions.ValueOrNull(OverByte?) : Byte? + static op_LessThan(OverByte, OverByte) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverByte, OverByte) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverByteExtensions.GetValue(OverByte) : Byte [IValueObject.Value] + extension static OverByteExtensions.ValueOrNull(OverByte?) : Byte? [IValueObject.Value] OverChar - CompareTo(Object) : Int32 - CompareTo(OverChar) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverChar) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(OverChar) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Char + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Char [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4556,33 +4556,33 @@ OverChar implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverCharJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverCharTypeConverter : TypeConverter + nested OverCharJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverCharJsonConverter] + nested OverCharTypeConverter : TypeConverter [IValue.OverCharTypeConverter] new() - static From(Char) : OverChar - static MaxValue : OverChar - static MinValue : OverChar - static Parse(ReadOnlySpan, IFormatProvider) : OverChar - static Parse(ReadOnlySpan, IFormatProvider) : OverChar - static Parse(String, IFormatProvider) : OverChar - static TryParse(ReadOnlySpan, IFormatProvider, out OverChar) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out OverChar) : Boolean - static TryParse(String, IFormatProvider, out OverChar) : Boolean + static From(Char) : OverChar [IPlainValueObject.From] + static MaxValue : OverChar [IMinMaxValue.MaxValue] + static MinValue : OverChar [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : OverChar [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : OverChar [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : OverChar [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverChar) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverChar) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverChar) : Boolean [IParsable.TryParse] static op_Equality(OverChar, OverChar) : Boolean - static op_GreaterThan(OverChar, OverChar) : Boolean - static op_GreaterThanOrEqual(OverChar, OverChar) : Boolean + static op_GreaterThan(OverChar, OverChar) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverChar, OverChar) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverChar, OverChar) : Boolean - static op_LessThan(OverChar, OverChar) : Boolean - static op_LessThanOrEqual(OverChar, OverChar) : Boolean - extension static OverCharExtensions.GetValue(OverChar) : Char - extension static OverCharExtensions.ValueOrNull(OverChar?) : Char? + static op_LessThan(OverChar, OverChar) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverChar, OverChar) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverCharExtensions.GetValue(OverChar) : Char [IValueObject.Value] + extension static OverCharExtensions.ValueOrNull(OverChar?) : Char? [IValueObject.Value] OverCode Equals(Object) : Boolean Equals(OverCode) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : Code + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : Code [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4595,23 +4595,23 @@ OverCode implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverCodeJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverCodeTypeConverter : TypeConverter + nested OverCodeJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverCodeJsonConverter] + nested OverCodeTypeConverter : TypeConverter [IValue.OverCodeTypeConverter] new() - static From(Code) : OverCode - static Parse(String, IFormatProvider) : OverCode - static TryParse(String, IFormatProvider, out OverCode) : Boolean + static From(Code) : OverCode [IPlainValueObject.From] + static Parse(String, IFormatProvider) : OverCode [IParsable.Parse] + static TryParse(String, IFormatProvider, out OverCode) : Boolean [IParsable.TryParse] static op_Equality(OverCode, OverCode) : Boolean static op_Inequality(OverCode, OverCode) : Boolean - extension static OverCodeExtensions.GetValue(OverCode) : Code - extension static OverCodeExtensions.ValueOrNull(OverCode?) : Code? + extension static OverCodeExtensions.GetValue(OverCode) : Code [IValueObject.Value] + extension static OverCodeExtensions.ValueOrNull(OverCode?) : Code? [IValueObject.Value] OverConstructedAbstract Equals(Object) : Boolean Equals(OverConstructedAbstract) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : ConstructedAbstract + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ConstructedAbstract [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4622,20 +4622,20 @@ OverConstructedAbstract implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverConstructedAbstractJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverConstructedAbstractJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverConstructedAbstractJsonConverter] new() - static From(ConstructedAbstract) : OverConstructedAbstract + static From(ConstructedAbstract) : OverConstructedAbstract [IPlainValueObject.From] static op_Equality(OverConstructedAbstract, OverConstructedAbstract) : Boolean static op_Inequality(OverConstructedAbstract, OverConstructedAbstract) : Boolean - extension static OverConstructedAbstractExtensions.GetValue(OverConstructedAbstract) : ConstructedAbstract - extension static OverConstructedAbstractExtensions.ValueOrNull(OverConstructedAbstract?) : ConstructedAbstract + extension static OverConstructedAbstractExtensions.GetValue(OverConstructedAbstract) : ConstructedAbstract [IValueObject.Value] + extension static OverConstructedAbstractExtensions.ValueOrNull(OverConstructedAbstract?) : ConstructedAbstract [IValueObject.Value] OverConstructedByRef Equals(Object) : Boolean Equals(OverConstructedByRef) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : ConstructedByRef + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ConstructedByRef [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4646,20 +4646,20 @@ OverConstructedByRef implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverConstructedByRefJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverConstructedByRefJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverConstructedByRefJsonConverter] new() - static From(ConstructedByRef) : OverConstructedByRef + static From(ConstructedByRef) : OverConstructedByRef [IPlainValueObject.From] static op_Equality(OverConstructedByRef, OverConstructedByRef) : Boolean static op_Inequality(OverConstructedByRef, OverConstructedByRef) : Boolean - extension static OverConstructedByRefExtensions.GetValue(OverConstructedByRef) : ConstructedByRef - extension static OverConstructedByRefExtensions.ValueOrNull(OverConstructedByRef?) : ConstructedByRef + extension static OverConstructedByRefExtensions.GetValue(OverConstructedByRef) : ConstructedByRef [IValueObject.Value] + extension static OverConstructedByRefExtensions.ValueOrNull(OverConstructedByRef?) : ConstructedByRef [IValueObject.Value] OverConstructedFromIn Equals(Object) : Boolean Equals(OverConstructedFromIn) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : ConstructedFromIn + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ConstructedFromIn [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4672,23 +4672,23 @@ OverConstructedFromIn implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverConstructedFromInJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverConstructedFromInTypeConverter : TypeConverter + nested OverConstructedFromInJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverConstructedFromInJsonConverter] + nested OverConstructedFromInTypeConverter : TypeConverter [IValue.OverConstructedFromInTypeConverter] new() - static From(ConstructedFromIn) : OverConstructedFromIn - static Parse(String, IFormatProvider) : OverConstructedFromIn - static TryParse(String, IFormatProvider, out OverConstructedFromIn) : Boolean + static From(ConstructedFromIn) : OverConstructedFromIn [IPlainValueObject.From] + static Parse(String, IFormatProvider) : OverConstructedFromIn [IParsable.Parse] + static TryParse(String, IFormatProvider, out OverConstructedFromIn) : Boolean [IParsable.TryParse] static op_Equality(OverConstructedFromIn, OverConstructedFromIn) : Boolean static op_Inequality(OverConstructedFromIn, OverConstructedFromIn) : Boolean - extension static OverConstructedFromInExtensions.GetValue(OverConstructedFromIn) : ConstructedFromIn - extension static OverConstructedFromInExtensions.ValueOrNull(OverConstructedFromIn?) : ConstructedFromIn + extension static OverConstructedFromInExtensions.GetValue(OverConstructedFromIn) : ConstructedFromIn [IValueObject.Value] + extension static OverConstructedFromInExtensions.ValueOrNull(OverConstructedFromIn?) : ConstructedFromIn [IValueObject.Value] OverDisposable Equals(Object) : Boolean Equals(OverDisposable) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : IDisposable + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : IDisposable [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4699,20 +4699,20 @@ OverDisposable implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverDisposableJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverDisposableJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverDisposableJsonConverter] new() - static From(IDisposable) : OverDisposable + static From(IDisposable) : OverDisposable [IPlainValueObject.From] static op_Equality(OverDisposable, OverDisposable) : Boolean static op_Inequality(OverDisposable, OverDisposable) : Boolean - extension static OverDisposableExtensions.GetValue(OverDisposable) : IDisposable - extension static OverDisposableExtensions.ValueOrNull(OverDisposable?) : IDisposable + extension static OverDisposableExtensions.GetValue(OverDisposable) : IDisposable [IValueObject.Value] + extension static OverDisposableExtensions.ValueOrNull(OverDisposable?) : IDisposable [IValueObject.Value] OverGenericParser Equals(Object) : Boolean Equals(OverGenericParser) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : GenericParser + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : GenericParser [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4723,20 +4723,20 @@ OverGenericParser implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverGenericParserJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverGenericParserJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverGenericParserJsonConverter] new() - static From(GenericParser) : OverGenericParser + static From(GenericParser) : OverGenericParser [IPlainValueObject.From] static op_Equality(OverGenericParser, OverGenericParser) : Boolean static op_Inequality(OverGenericParser, OverGenericParser) : Boolean - extension static OverGenericParserExtensions.GetValue(OverGenericParser) : GenericParser - extension static OverGenericParserExtensions.ValueOrNull(OverGenericParser?) : GenericParser + extension static OverGenericParserExtensions.GetValue(OverGenericParser) : GenericParser [IValueObject.Value] + extension static OverGenericParserExtensions.ValueOrNull(OverGenericParser?) : GenericParser [IValueObject.Value] OverHoldingAnything Equals(Object) : Boolean Equals(OverHoldingAnything) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : HoldingAnything + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : HoldingAnything [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4747,20 +4747,20 @@ OverHoldingAnything implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverHoldingAnythingJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverHoldingAnythingJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverHoldingAnythingJsonConverter] new() - static From(HoldingAnything) : OverHoldingAnything + static From(HoldingAnything) : OverHoldingAnything [IPlainValueObject.From] static op_Equality(OverHoldingAnything, OverHoldingAnything) : Boolean static op_Inequality(OverHoldingAnything, OverHoldingAnything) : Boolean - extension static OverHoldingAnythingExtensions.GetValue(OverHoldingAnything) : HoldingAnything - extension static OverHoldingAnythingExtensions.ValueOrNull(OverHoldingAnything?) : HoldingAnything? + extension static OverHoldingAnythingExtensions.GetValue(OverHoldingAnything) : HoldingAnything [IValueObject.Value] + extension static OverHoldingAnythingExtensions.ValueOrNull(OverHoldingAnything?) : HoldingAnything? [IValueObject.Value] OverHoldingIgnored Equals(Object) : Boolean Equals(OverHoldingIgnored) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : HoldingIgnored + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : HoldingIgnored [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4771,20 +4771,20 @@ OverHoldingIgnored implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverHoldingIgnoredJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverHoldingIgnoredJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverHoldingIgnoredJsonConverter] new() - static From(HoldingIgnored) : OverHoldingIgnored + static From(HoldingIgnored) : OverHoldingIgnored [IPlainValueObject.From] static op_Equality(OverHoldingIgnored, OverHoldingIgnored) : Boolean static op_Inequality(OverHoldingIgnored, OverHoldingIgnored) : Boolean - extension static OverHoldingIgnoredExtensions.GetValue(OverHoldingIgnored) : HoldingIgnored - extension static OverHoldingIgnoredExtensions.ValueOrNull(OverHoldingIgnored?) : HoldingIgnored? + extension static OverHoldingIgnoredExtensions.GetValue(OverHoldingIgnored) : HoldingIgnored [IValueObject.Value] + extension static OverHoldingIgnoredExtensions.ValueOrNull(OverHoldingIgnored?) : HoldingIgnored? [IValueObject.Value] OverHoldingNamedHolder Equals(Object) : Boolean Equals(OverHoldingNamedHolder) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : HoldingNamedHolder + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : HoldingNamedHolder [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4795,20 +4795,20 @@ OverHoldingNamedHolder implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverHoldingNamedHolderJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverHoldingNamedHolderJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverHoldingNamedHolderJsonConverter] new() - static From(HoldingNamedHolder) : OverHoldingNamedHolder + static From(HoldingNamedHolder) : OverHoldingNamedHolder [IPlainValueObject.From] static op_Equality(OverHoldingNamedHolder, OverHoldingNamedHolder) : Boolean static op_Inequality(OverHoldingNamedHolder, OverHoldingNamedHolder) : Boolean - extension static OverHoldingNamedHolderExtensions.GetValue(OverHoldingNamedHolder) : HoldingNamedHolder - extension static OverHoldingNamedHolderExtensions.ValueOrNull(OverHoldingNamedHolder?) : HoldingNamedHolder? + extension static OverHoldingNamedHolderExtensions.GetValue(OverHoldingNamedHolder) : HoldingNamedHolder [IValueObject.Value] + extension static OverHoldingNamedHolderExtensions.ValueOrNull(OverHoldingNamedHolder?) : HoldingNamedHolder? [IValueObject.Value] OverHoldingNamedShade Equals(Object) : Boolean Equals(OverHoldingNamedShade) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : HoldingNamedShade + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : HoldingNamedShade [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4819,20 +4819,20 @@ OverHoldingNamedShade implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverHoldingNamedShadeJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverHoldingNamedShadeJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverHoldingNamedShadeJsonConverter] new() - static From(HoldingNamedShade) : OverHoldingNamedShade + static From(HoldingNamedShade) : OverHoldingNamedShade [IPlainValueObject.From] static op_Equality(OverHoldingNamedShade, OverHoldingNamedShade) : Boolean static op_Inequality(OverHoldingNamedShade, OverHoldingNamedShade) : Boolean - extension static OverHoldingNamedShadeExtensions.GetValue(OverHoldingNamedShade) : HoldingNamedShade - extension static OverHoldingNamedShadeExtensions.ValueOrNull(OverHoldingNamedShade?) : HoldingNamedShade? + extension static OverHoldingNamedShadeExtensions.GetValue(OverHoldingNamedShade) : HoldingNamedShade [IValueObject.Value] + extension static OverHoldingNamedShadeExtensions.ValueOrNull(OverHoldingNamedShade?) : HoldingNamedShade? [IValueObject.Value] OverHoldingNullableHolder Equals(Object) : Boolean Equals(OverHoldingNullableHolder) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : HoldingNullableHolder + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : HoldingNullableHolder [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4843,20 +4843,20 @@ OverHoldingNullableHolder implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverHoldingNullableHolderJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverHoldingNullableHolderJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverHoldingNullableHolderJsonConverter] new() - static From(HoldingNullableHolder) : OverHoldingNullableHolder + static From(HoldingNullableHolder) : OverHoldingNullableHolder [IPlainValueObject.From] static op_Equality(OverHoldingNullableHolder, OverHoldingNullableHolder) : Boolean static op_Inequality(OverHoldingNullableHolder, OverHoldingNullableHolder) : Boolean - extension static OverHoldingNullableHolderExtensions.GetValue(OverHoldingNullableHolder) : HoldingNullableHolder - extension static OverHoldingNullableHolderExtensions.ValueOrNull(OverHoldingNullableHolder?) : HoldingNullableHolder? + extension static OverHoldingNullableHolderExtensions.GetValue(OverHoldingNullableHolder) : HoldingNullableHolder [IValueObject.Value] + extension static OverHoldingNullableHolderExtensions.ValueOrNull(OverHoldingNullableHolder?) : HoldingNullableHolder? [IValueObject.Value] OverHoldingTracked Equals(Object) : Boolean Equals(OverHoldingTracked) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : HoldingTracked + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : HoldingTracked [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4867,20 +4867,20 @@ OverHoldingTracked implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverHoldingTrackedJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverHoldingTrackedJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverHoldingTrackedJsonConverter] new() - static From(HoldingTracked) : OverHoldingTracked + static From(HoldingTracked) : OverHoldingTracked [IPlainValueObject.From] static op_Equality(OverHoldingTracked, OverHoldingTracked) : Boolean static op_Inequality(OverHoldingTracked, OverHoldingTracked) : Boolean - extension static OverHoldingTrackedExtensions.GetValue(OverHoldingTracked) : HoldingTracked - extension static OverHoldingTrackedExtensions.ValueOrNull(OverHoldingTracked?) : HoldingTracked? + extension static OverHoldingTrackedExtensions.GetValue(OverHoldingTracked) : HoldingTracked [IValueObject.Value] + extension static OverHoldingTrackedExtensions.ValueOrNull(OverHoldingTracked?) : HoldingTracked? [IValueObject.Value] OverLabels Equals(Object) : Boolean Equals(OverLabels) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : Labels + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : Labels [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4891,22 +4891,22 @@ OverLabels implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverLabelsJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverLabelsJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverLabelsJsonConverter] new() - static From(Labels) : OverLabels + static From(Labels) : OverLabels [IPlainValueObject.From] static op_Equality(OverLabels, OverLabels) : Boolean static op_Inequality(OverLabels, OverLabels) : Boolean - extension static OverLabelsExtensions.GetValue(OverLabels) : Labels - extension static OverLabelsExtensions.ValueOrNull(OverLabels?) : Labels? + extension static OverLabelsExtensions.GetValue(OverLabels) : Labels [IValueObject.Value] + extension static OverLabelsExtensions.ValueOrNull(OverLabels?) : Labels? [IValueObject.Value] OverLocalTime - CompareTo(Object) : Int32 - CompareTo(OverLocalTime) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverLocalTime) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(OverLocalTime) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : LocalTime + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : LocalTime [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4923,33 +4923,33 @@ OverLocalTime implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverLocalTimeJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverLocalTimeTypeConverter : TypeConverter + nested OverLocalTimeJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverLocalTimeJsonConverter] + nested OverLocalTimeTypeConverter : TypeConverter [IValue.OverLocalTimeTypeConverter] new() - static From(LocalTime) : OverLocalTime - static MaxValue : OverLocalTime - static MinValue : OverLocalTime - static Parse(String, IFormatProvider) : OverLocalTime - static TryParse(String, IFormatProvider, out OverLocalTime) : Boolean + static From(LocalTime) : OverLocalTime [IPlainValueObject.From] + static MaxValue : OverLocalTime [IMinMaxValue.MaxValue] + static MinValue : OverLocalTime [IMinMaxValue.MinValue] + static Parse(String, IFormatProvider) : OverLocalTime [IParsable.Parse] + static TryParse(String, IFormatProvider, out OverLocalTime) : Boolean [IParsable.TryParse] static op_Equality(OverLocalTime, OverLocalTime) : Boolean - static op_GreaterThan(OverLocalTime, OverLocalTime) : Boolean - static op_GreaterThanOrEqual(OverLocalTime, OverLocalTime) : Boolean + static op_GreaterThan(OverLocalTime, OverLocalTime) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverLocalTime, OverLocalTime) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverLocalTime, OverLocalTime) : Boolean - static op_LessThan(OverLocalTime, OverLocalTime) : Boolean - static op_LessThanOrEqual(OverLocalTime, OverLocalTime) : Boolean - extension static OverLocalTimeExtensions.GetValue(OverLocalTime) : LocalTime - extension static OverLocalTimeExtensions.ValueOrNull(OverLocalTime?) : LocalTime? + static op_LessThan(OverLocalTime, OverLocalTime) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverLocalTime, OverLocalTime) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverLocalTimeExtensions.GetValue(OverLocalTime) : LocalTime [IValueObject.Value] + extension static OverLocalTimeExtensions.ValueOrNull(OverLocalTime?) : LocalTime? [IValueObject.Value] OverLong - CompareTo(Object) : Int32 - CompareTo(OverLong) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverLong) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(OverLong) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int64 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int64 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -4971,33 +4971,33 @@ OverLong implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverLongJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverLongTypeConverter : TypeConverter + nested OverLongJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverLongJsonConverter] + nested OverLongTypeConverter : TypeConverter [IValue.OverLongTypeConverter] new() - static From(Int64) : OverLong - static MaxValue : OverLong - static MinValue : OverLong - static Parse(ReadOnlySpan, IFormatProvider) : OverLong - static Parse(ReadOnlySpan, IFormatProvider) : OverLong - static Parse(String, IFormatProvider) : OverLong - static TryParse(ReadOnlySpan, IFormatProvider, out OverLong) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out OverLong) : Boolean - static TryParse(String, IFormatProvider, out OverLong) : Boolean + static From(Int64) : OverLong [IPlainValueObject.From] + static MaxValue : OverLong [IMinMaxValue.MaxValue] + static MinValue : OverLong [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : OverLong [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : OverLong [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : OverLong [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverLong) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverLong) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverLong) : Boolean [IParsable.TryParse] static op_Equality(OverLong, OverLong) : Boolean - static op_GreaterThan(OverLong, OverLong) : Boolean - static op_GreaterThanOrEqual(OverLong, OverLong) : Boolean + static op_GreaterThan(OverLong, OverLong) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverLong, OverLong) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverLong, OverLong) : Boolean - static op_LessThan(OverLong, OverLong) : Boolean - static op_LessThanOrEqual(OverLong, OverLong) : Boolean - extension static OverLongExtensions.GetValue(OverLong) : Int64 - extension static OverLongExtensions.ValueOrNull(OverLong?) : Int64? + static op_LessThan(OverLong, OverLong) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverLong, OverLong) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverLongExtensions.GetValue(OverLong) : Int64 [IValueObject.Value] + extension static OverLongExtensions.ValueOrNull(OverLong?) : Int64? [IValueObject.Value] OverParsedFromText Equals(Object) : Boolean Equals(OverParsedFromText) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : ParsedFromText + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ParsedFromText [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5010,23 +5010,23 @@ OverParsedFromText implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverParsedFromTextJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverParsedFromTextTypeConverter : TypeConverter + nested OverParsedFromTextJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverParsedFromTextJsonConverter] + nested OverParsedFromTextTypeConverter : TypeConverter [IValue.OverParsedFromTextTypeConverter] new() - static From(ParsedFromText) : OverParsedFromText - static Parse(String, IFormatProvider) : OverParsedFromText - static TryParse(String, IFormatProvider, out OverParsedFromText) : Boolean + static From(ParsedFromText) : OverParsedFromText [IPlainValueObject.From] + static Parse(String, IFormatProvider) : OverParsedFromText [IParsable.Parse] + static TryParse(String, IFormatProvider, out OverParsedFromText) : Boolean [IParsable.TryParse] static op_Equality(OverParsedFromText, OverParsedFromText) : Boolean static op_Inequality(OverParsedFromText, OverParsedFromText) : Boolean - extension static OverParsedFromTextExtensions.GetValue(OverParsedFromText) : ParsedFromText - extension static OverParsedFromTextExtensions.ValueOrNull(OverParsedFromText?) : ParsedFromText + extension static OverParsedFromTextExtensions.GetValue(OverParsedFromText) : ParsedFromText [IValueObject.Value] + extension static OverParsedFromTextExtensions.ValueOrNull(OverParsedFromText?) : ParsedFromText [IValueObject.Value] OverParsedShape Equals(Object) : Boolean Equals(OverParsedShape) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : ParsedShape + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ParsedShape [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5039,23 +5039,23 @@ OverParsedShape implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverParsedShapeJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverParsedShapeTypeConverter : TypeConverter + nested OverParsedShapeJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverParsedShapeJsonConverter] + nested OverParsedShapeTypeConverter : TypeConverter [IValue.OverParsedShapeTypeConverter] new() - static From(ParsedShape) : OverParsedShape - static Parse(String, IFormatProvider) : OverParsedShape - static TryParse(String, IFormatProvider, out OverParsedShape) : Boolean + static From(ParsedShape) : OverParsedShape [IPlainValueObject.From] + static Parse(String, IFormatProvider) : OverParsedShape [IParsable.Parse] + static TryParse(String, IFormatProvider, out OverParsedShape) : Boolean [IParsable.TryParse] static op_Equality(OverParsedShape, OverParsedShape) : Boolean static op_Inequality(OverParsedShape, OverParsedShape) : Boolean - extension static OverParsedShapeExtensions.GetValue(OverParsedShape) : ParsedShape - extension static OverParsedShapeExtensions.ValueOrNull(OverParsedShape?) : ParsedShape + extension static OverParsedShapeExtensions.GetValue(OverParsedShape) : ParsedShape [IValueObject.Value] + extension static OverParsedShapeExtensions.ValueOrNull(OverParsedShape?) : ParsedShape [IValueObject.Value] OverParsesFromIn Equals(Object) : Boolean Equals(OverParsesFromIn) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : ParsesFromIn + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ParsesFromIn [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5068,23 +5068,23 @@ OverParsesFromIn implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverParsesFromInJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverParsesFromInTypeConverter : TypeConverter + nested OverParsesFromInJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverParsesFromInJsonConverter] + nested OverParsesFromInTypeConverter : TypeConverter [IValue.OverParsesFromInTypeConverter] new() - static From(ParsesFromIn) : OverParsesFromIn - static Parse(String, IFormatProvider) : OverParsesFromIn - static TryParse(String, IFormatProvider, out OverParsesFromIn) : Boolean + static From(ParsesFromIn) : OverParsesFromIn [IPlainValueObject.From] + static Parse(String, IFormatProvider) : OverParsesFromIn [IParsable.Parse] + static TryParse(String, IFormatProvider, out OverParsesFromIn) : Boolean [IParsable.TryParse] static op_Equality(OverParsesFromIn, OverParsesFromIn) : Boolean static op_Inequality(OverParsesFromIn, OverParsesFromIn) : Boolean - extension static OverParsesFromInExtensions.GetValue(OverParsesFromIn) : ParsesFromIn - extension static OverParsesFromInExtensions.ValueOrNull(OverParsesFromIn?) : ParsesFromIn + extension static OverParsesFromInExtensions.GetValue(OverParsesFromIn) : ParsesFromIn [IValueObject.Value] + extension static OverParsesFromInExtensions.ValueOrNull(OverParsesFromIn?) : ParsesFromIn [IValueObject.Value] OverParsesToADerivedType Equals(Object) : Boolean Equals(OverParsesToADerivedType) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : ParsesToADerivedType + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ParsesToADerivedType [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5097,23 +5097,23 @@ OverParsesToADerivedType implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverParsesToADerivedTypeJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverParsesToADerivedTypeTypeConverter : TypeConverter + nested OverParsesToADerivedTypeJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverParsesToADerivedTypeJsonConverter] + nested OverParsesToADerivedTypeTypeConverter : TypeConverter [IValue.OverParsesToADerivedTypeTypeConverter] new() - static From(ParsesToADerivedType) : OverParsesToADerivedType - static Parse(String, IFormatProvider) : OverParsesToADerivedType - static TryParse(String, IFormatProvider, out OverParsesToADerivedType) : Boolean + static From(ParsesToADerivedType) : OverParsesToADerivedType [IPlainValueObject.From] + static Parse(String, IFormatProvider) : OverParsesToADerivedType [IParsable.Parse] + static TryParse(String, IFormatProvider, out OverParsesToADerivedType) : Boolean [IParsable.TryParse] static op_Equality(OverParsesToADerivedType, OverParsesToADerivedType) : Boolean static op_Inequality(OverParsesToADerivedType, OverParsesToADerivedType) : Boolean - extension static OverParsesToADerivedTypeExtensions.GetValue(OverParsesToADerivedType) : ParsesToADerivedType - extension static OverParsesToADerivedTypeExtensions.ValueOrNull(OverParsesToADerivedType?) : ParsesToADerivedType + extension static OverParsesToADerivedTypeExtensions.GetValue(OverParsesToADerivedType) : ParsesToADerivedType [IValueObject.Value] + extension static OverParsesToADerivedTypeExtensions.ValueOrNull(OverParsesToADerivedType?) : ParsesToADerivedType [IValueObject.Value] OverParsesToAnotherType Equals(Object) : Boolean Equals(OverParsesToAnotherType) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : ParsesToAnotherType + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ParsesToAnotherType [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5124,20 +5124,20 @@ OverParsesToAnotherType implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverParsesToAnotherTypeJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverParsesToAnotherTypeJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverParsesToAnotherTypeJsonConverter] new() - static From(ParsesToAnotherType) : OverParsesToAnotherType + static From(ParsesToAnotherType) : OverParsesToAnotherType [IPlainValueObject.From] static op_Equality(OverParsesToAnotherType, OverParsesToAnotherType) : Boolean static op_Inequality(OverParsesToAnotherType, OverParsesToAnotherType) : Boolean - extension static OverParsesToAnotherTypeExtensions.GetValue(OverParsesToAnotherType) : ParsesToAnotherType - extension static OverParsesToAnotherTypeExtensions.ValueOrNull(OverParsesToAnotherType?) : ParsesToAnotherType + extension static OverParsesToAnotherTypeExtensions.GetValue(OverParsesToAnotherType) : ParsesToAnotherType [IValueObject.Value] + extension static OverParsesToAnotherTypeExtensions.ValueOrNull(OverParsesToAnotherType?) : ParsesToAnotherType [IValueObject.Value] OverParsesVirtually Equals(Object) : Boolean Equals(OverParsesVirtually) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : IParsesVirtually + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : IParsesVirtually [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5148,26 +5148,26 @@ OverParsesVirtually implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverParsesVirtuallyJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverParsesVirtuallyJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverParsesVirtuallyJsonConverter] new() - static From(IParsesVirtually) : OverParsesVirtually + static From(IParsesVirtually) : OverParsesVirtually [IPlainValueObject.From] static op_Equality(OverParsesVirtually, OverParsesVirtually) : Boolean static op_Inequality(OverParsesVirtually, OverParsesVirtually) : Boolean - extension static OverParsesVirtuallyExtensions.GetValue(OverParsesVirtually) : IParsesVirtually - extension static OverParsesVirtuallyExtensions.ValueOrNull(OverParsesVirtually?) : IParsesVirtually + extension static OverParsesVirtuallyExtensions.GetValue(OverParsesVirtually) : IParsesVirtually [IValueObject.Value] + extension static OverParsesVirtuallyExtensions.ValueOrNull(OverParsesVirtually?) : IParsesVirtually [IValueObject.Value] OverPrivateNames $() : OverPrivateNames - CompareTo(Object) : Int32 - CompareTo(OverPrivateNames) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverPrivateNames) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(OverPrivateNames) : Boolean Equals(PrivateNamesBase) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5191,32 +5191,32 @@ OverPrivateNames implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverPrivateNamesJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverPrivateNamesTypeConverter : TypeConverter - static From(Int32) : OverPrivateNames - static MaxValue : OverPrivateNames - static MinValue : OverPrivateNames - static Parse(ReadOnlySpan, IFormatProvider) : OverPrivateNames - static Parse(ReadOnlySpan, IFormatProvider) : OverPrivateNames - static Parse(String, IFormatProvider) : OverPrivateNames - static TryParse(ReadOnlySpan, IFormatProvider, out OverPrivateNames) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out OverPrivateNames) : Boolean - static TryParse(String, IFormatProvider, out OverPrivateNames) : Boolean + nested OverPrivateNamesJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverPrivateNamesJsonConverter] + nested OverPrivateNamesTypeConverter : TypeConverter [IValue.OverPrivateNamesTypeConverter] + static From(Int32) : OverPrivateNames [IPlainValueObject.From] + static MaxValue : OverPrivateNames [IMinMaxValue.MaxValue] + static MinValue : OverPrivateNames [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : OverPrivateNames [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : OverPrivateNames [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : OverPrivateNames [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverPrivateNames) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverPrivateNames) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverPrivateNames) : Boolean [IParsable.TryParse] static op_Equality(OverPrivateNames, OverPrivateNames) : Boolean - static op_GreaterThan(OverPrivateNames, OverPrivateNames) : Boolean - static op_GreaterThanOrEqual(OverPrivateNames, OverPrivateNames) : Boolean + static op_GreaterThan(OverPrivateNames, OverPrivateNames) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverPrivateNames, OverPrivateNames) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverPrivateNames, OverPrivateNames) : Boolean - static op_LessThan(OverPrivateNames, OverPrivateNames) : Boolean - static op_LessThanOrEqual(OverPrivateNames, OverPrivateNames) : Boolean - extension static OverPrivateNamesExtensions.GetValue(OverPrivateNames) : Int32 - extension static OverPrivateNamesExtensions.ValueOrNull(OverPrivateNames) : Int32? + static op_LessThan(OverPrivateNames, OverPrivateNames) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverPrivateNames, OverPrivateNames) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverPrivateNamesExtensions.GetValue(OverPrivateNames) : Int32 [IValueObject.Value] + extension static OverPrivateNamesExtensions.ValueOrNull(OverPrivateNames) : Int32? [IValueObject.Value] OverProbeStatus Equals(Object) : Boolean Equals(OverProbeStatus) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : ProbeStatus + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ProbeStatus [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5229,23 +5229,23 @@ OverProbeStatus implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverProbeStatusJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverProbeStatusTypeConverter : TypeConverter + nested OverProbeStatusJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverProbeStatusJsonConverter] + nested OverProbeStatusTypeConverter : TypeConverter [IValue.OverProbeStatusTypeConverter] new() - static From(ProbeStatus) : OverProbeStatus - static Parse(String, IFormatProvider) : OverProbeStatus - static TryParse(String, IFormatProvider, out OverProbeStatus) : Boolean + static From(ProbeStatus) : OverProbeStatus [IPlainValueObject.From] + static Parse(String, IFormatProvider) : OverProbeStatus [IParsable.Parse] + static TryParse(String, IFormatProvider, out OverProbeStatus) : Boolean [IParsable.TryParse] static op_Equality(OverProbeStatus, OverProbeStatus) : Boolean static op_Inequality(OverProbeStatus, OverProbeStatus) : Boolean - extension static OverProbeStatusExtensions.GetValue(OverProbeStatus) : ProbeStatus - extension static OverProbeStatusExtensions.ValueOrNull(OverProbeStatus?) : ProbeStatus + extension static OverProbeStatusExtensions.GetValue(OverProbeStatus) : ProbeStatus [IValueObject.Value] + extension static OverProbeStatusExtensions.ValueOrNull(OverProbeStatus?) : ProbeStatus [IValueObject.Value] OverStream Equals(Object) : Boolean Equals(OverStream) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : Stream + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : Stream [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5256,20 +5256,20 @@ OverStream implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverStreamJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverStreamJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverStreamJsonConverter] new() - static From(Stream) : OverStream + static From(Stream) : OverStream [IPlainValueObject.From] static op_Equality(OverStream, OverStream) : Boolean static op_Inequality(OverStream, OverStream) : Boolean - extension static OverStreamExtensions.GetValue(OverStream) : Stream - extension static OverStreamExtensions.ValueOrNull(OverStream?) : Stream + extension static OverStreamExtensions.GetValue(OverStream) : Stream [IValueObject.Value] + extension static OverStreamExtensions.ValueOrNull(OverStream?) : Stream [IValueObject.Value] OverTracked Equals(Object) : Boolean Equals(OverTracked) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : Tracked + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : Tracked [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5280,20 +5280,20 @@ OverTracked implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverTrackedJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverTrackedJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverTrackedJsonConverter] new() - static From(Tracked) : OverTracked + static From(Tracked) : OverTracked [IPlainValueObject.From] static op_Equality(OverTracked, OverTracked) : Boolean static op_Inequality(OverTracked, OverTracked) : Boolean - extension static OverTrackedExtensions.GetValue(OverTracked) : Tracked - extension static OverTrackedExtensions.ValueOrNull(OverTracked?) : Tracked + extension static OverTrackedExtensions.GetValue(OverTracked) : Tracked [IValueObject.Value] + extension static OverTrackedExtensions.ValueOrNull(OverTracked?) : Tracked [IValueObject.Value] OverTrackedList Equals(Object) : Boolean Equals(OverTrackedList) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : TrackedList + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : TrackedList [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5304,24 +5304,24 @@ OverTrackedList implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverTrackedListJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverTrackedListJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverTrackedListJsonConverter] new() - static From(TrackedList) : OverTrackedList + static From(TrackedList) : OverTrackedList [IPlainValueObject.From] static op_Equality(OverTrackedList, OverTrackedList) : Boolean static op_Inequality(OverTrackedList, OverTrackedList) : Boolean - extension static OverTrackedListExtensions.GetValue(OverTrackedList) : TrackedList - extension static OverTrackedListExtensions.ValueOrNull(OverTrackedList?) : TrackedList? + extension static OverTrackedListExtensions.GetValue(OverTrackedList) : TrackedList [IValueObject.Value] + extension static OverTrackedListExtensions.ValueOrNull(OverTrackedList?) : TrackedList? [IValueObject.Value] OverUInt64 - CompareTo(Object) : Int32 - CompareTo(OverUInt64) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverUInt64) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(OverUInt64) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : UInt64 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : UInt64 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5343,33 +5343,33 @@ OverUInt64 implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverUInt64JsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverUInt64TypeConverter : TypeConverter + nested OverUInt64JsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverUInt64JsonConverter] + nested OverUInt64TypeConverter : TypeConverter [IValue.OverUInt64TypeConverter] new() - static From(UInt64) : OverUInt64 - static MaxValue : OverUInt64 - static MinValue : OverUInt64 - static Parse(ReadOnlySpan, IFormatProvider) : OverUInt64 - static Parse(ReadOnlySpan, IFormatProvider) : OverUInt64 - static Parse(String, IFormatProvider) : OverUInt64 - static TryParse(ReadOnlySpan, IFormatProvider, out OverUInt64) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out OverUInt64) : Boolean - static TryParse(String, IFormatProvider, out OverUInt64) : Boolean + static From(UInt64) : OverUInt64 [IPlainValueObject.From] + static MaxValue : OverUInt64 [IMinMaxValue.MaxValue] + static MinValue : OverUInt64 [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : OverUInt64 [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : OverUInt64 [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : OverUInt64 [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverUInt64) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverUInt64) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverUInt64) : Boolean [IParsable.TryParse] static op_Equality(OverUInt64, OverUInt64) : Boolean - static op_GreaterThan(OverUInt64, OverUInt64) : Boolean - static op_GreaterThanOrEqual(OverUInt64, OverUInt64) : Boolean + static op_GreaterThan(OverUInt64, OverUInt64) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverUInt64, OverUInt64) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverUInt64, OverUInt64) : Boolean - static op_LessThan(OverUInt64, OverUInt64) : Boolean - static op_LessThanOrEqual(OverUInt64, OverUInt64) : Boolean - extension static OverUInt64Extensions.GetValue(OverUInt64) : UInt64 - extension static OverUInt64Extensions.ValueOrNull(OverUInt64?) : UInt64? + static op_LessThan(OverUInt64, OverUInt64) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverUInt64, OverUInt64) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverUInt64Extensions.GetValue(OverUInt64) : UInt64 [IValueObject.Value] + extension static OverUInt64Extensions.ValueOrNull(OverUInt64?) : UInt64? [IValueObject.Value] OverUntracked Equals(Object) : Boolean Equals(OverUntracked) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : Untracked + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : Untracked [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5380,20 +5380,20 @@ OverUntracked implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverUntrackedJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverUntrackedJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverUntrackedJsonConverter] new() - static From(Untracked) : OverUntracked + static From(Untracked) : OverUntracked [IPlainValueObject.From] static op_Equality(OverUntracked, OverUntracked) : Boolean static op_Inequality(OverUntracked, OverUntracked) : Boolean - extension static OverUntrackedExtensions.GetValue(OverUntracked) : Untracked - extension static OverUntrackedExtensions.ValueOrNull(OverUntracked?) : Untracked? + extension static OverUntrackedExtensions.GetValue(OverUntracked) : Untracked [IValueObject.Value] + extension static OverUntrackedExtensions.ValueOrNull(OverUntracked?) : Untracked? [IValueObject.Value] OverUntrackedTwice Equals(Object) : Boolean Equals(OverUntrackedTwice) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : UntrackedTwice + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : UntrackedTwice [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5404,24 +5404,24 @@ OverUntrackedTwice implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverUntrackedTwiceJsonConverter : JsonConverter, IStoredJsonConverterSource + nested OverUntrackedTwiceJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverUntrackedTwiceJsonConverter] new() - static From(UntrackedTwice) : OverUntrackedTwice + static From(UntrackedTwice) : OverUntrackedTwice [IPlainValueObject.From] static op_Equality(OverUntrackedTwice, OverUntrackedTwice) : Boolean static op_Inequality(OverUntrackedTwice, OverUntrackedTwice) : Boolean - extension static OverUntrackedTwiceExtensions.GetValue(OverUntrackedTwice) : UntrackedTwice - extension static OverUntrackedTwiceExtensions.ValueOrNull(OverUntrackedTwice?) : UntrackedTwice? + extension static OverUntrackedTwiceExtensions.GetValue(OverUntrackedTwice) : UntrackedTwice [IValueObject.Value] + extension static OverUntrackedTwiceExtensions.ValueOrNull(OverUntrackedTwice?) : UntrackedTwice? [IValueObject.Value] OverVersion - CompareTo(Object) : Int32 - CompareTo(OverVersion) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(OverVersion) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(OverVersion) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Version + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Version [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5440,56 +5440,56 @@ OverVersion implements IValue implements IValueObject implements IValueObjectMaterializer - nested OverVersionJsonConverter : JsonConverter, IStoredJsonConverterSource - nested OverVersionTypeConverter : TypeConverter + nested OverVersionJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.OverVersionJsonConverter] + nested OverVersionTypeConverter : TypeConverter [IValue.OverVersionTypeConverter] new() - static From(Version) : OverVersion - static Parse(ReadOnlySpan, IFormatProvider) : OverVersion - static Parse(String, IFormatProvider) : OverVersion - static TryParse(ReadOnlySpan, IFormatProvider, out OverVersion) : Boolean - static TryParse(String, IFormatProvider, out OverVersion) : Boolean + static From(Version) : OverVersion [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : OverVersion [IUtf8SpanParsable.Parse] + static Parse(String, IFormatProvider) : OverVersion [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out OverVersion) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(String, IFormatProvider, out OverVersion) : Boolean [IParsable.TryParse] static op_Equality(OverVersion, OverVersion) : Boolean - static op_GreaterThan(OverVersion, OverVersion) : Boolean - static op_GreaterThanOrEqual(OverVersion, OverVersion) : Boolean + static op_GreaterThan(OverVersion, OverVersion) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(OverVersion, OverVersion) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(OverVersion, OverVersion) : Boolean - static op_LessThan(OverVersion, OverVersion) : Boolean - static op_LessThanOrEqual(OverVersion, OverVersion) : Boolean - extension static OverVersionExtensions.GetValue(OverVersion) : Version - extension static OverVersionExtensions.ValueOrNull(OverVersion?) : Version + static op_LessThan(OverVersion, OverVersion) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(OverVersion, OverVersion) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static OverVersionExtensions.GetValue(OverVersion) : Version [IValueObject.Value] + extension static OverVersionExtensions.ValueOrNull(OverVersion?) : Version [IValueObject.Value] OverloadingSet - Match(Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested OverloadingSetJsonConverter : JsonConverter - nested OverloadingSetTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : OverloadingSet - static Parse(String, Boolean) : OverloadingSet + nested OverloadingSetJsonConverter : JsonConverter [IClosedSet.OverloadingSetJsonConverter] + nested OverloadingSetTypeConverter : TypeConverter [IClosedSet.OverloadingSetTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : OverloadingSet [IClosedSet.Parse] + static Parse(String, Boolean) : OverloadingSet [IClosedSet.Parse] static Parse(String) : OverloadingSet static Parse(String, Boolean) : OverloadingSet static TryParse(String, Boolean, OverloadingSet) : Boolean - static TryParse(String, Boolean, out OverloadingSet) : Boolean + static TryParse(String, Boolean, out OverloadingSet) : Boolean [IClosedSet.TryParse] static TryParse(String, OverloadingSet) : Boolean - static TryParse(String, out OverloadingSet) : Boolean + static TryParse(String, out OverloadingSet) : Boolean [IClosedSet.TryParse] static TryParse(String, out OverloadingSet) : Boolean ParityByte - CompareTo(Object) : Int32 - CompareTo(ParityByte) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ParityByte) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ParityByte) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Byte + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Byte [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5511,37 +5511,37 @@ ParityByte implements IValue implements IValueObject implements IValueObjectMaterializer - nested ParityByteJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ParityByteTypeConverter : TypeConverter + nested ParityByteJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ParityByteJsonConverter] + nested ParityByteTypeConverter : TypeConverter [IValue.ParityByteTypeConverter] new() - static From(Byte) : ParityByte - static MaxValue : ParityByte - static MinValue : ParityByte - static Parse(ReadOnlySpan, IFormatProvider) : ParityByte - static Parse(ReadOnlySpan, IFormatProvider) : ParityByte - static Parse(String, IFormatProvider) : ParityByte - static TryParse(ReadOnlySpan, IFormatProvider, out ParityByte) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ParityByte) : Boolean - static TryParse(String, IFormatProvider, out ParityByte) : Boolean + static From(Byte) : ParityByte [IPlainValueObject.From] + static MaxValue : ParityByte [IMinMaxValue.MaxValue] + static MinValue : ParityByte [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ParityByte [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ParityByte [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ParityByte [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityByte) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityByte) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ParityByte) : Boolean [IParsable.TryParse] static op_Equality(ParityByte, ParityByte) : Boolean - static op_GreaterThan(ParityByte, ParityByte) : Boolean - static op_GreaterThanOrEqual(ParityByte, ParityByte) : Boolean + static op_GreaterThan(ParityByte, ParityByte) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ParityByte, ParityByte) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ParityByte, ParityByte) : Boolean - static op_LessThan(ParityByte, ParityByte) : Boolean - static op_LessThanOrEqual(ParityByte, ParityByte) : Boolean - extension static ParityByteExtensions.GetValue(ParityByte) : Byte - extension static ParityByteExtensions.ValueOrNull(ParityByte?) : Byte? + static op_LessThan(ParityByte, ParityByte) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ParityByte, ParityByte) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ParityByteExtensions.GetValue(ParityByte) : Byte [IValueObject.Value] + extension static ParityByteExtensions.ValueOrNull(ParityByte?) : Byte? [IValueObject.Value] ParityFloat - CompareTo(Object) : Int32 - CompareTo(ParityFloat) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ParityFloat) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ParityFloat) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Single + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Single [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5563,37 +5563,37 @@ ParityFloat implements IValue implements IValueObject implements IValueObjectMaterializer - nested ParityFloatJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ParityFloatTypeConverter : TypeConverter + nested ParityFloatJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ParityFloatJsonConverter] + nested ParityFloatTypeConverter : TypeConverter [IValue.ParityFloatTypeConverter] new() - static From(Single) : ParityFloat - static MaxValue : ParityFloat - static MinValue : ParityFloat - static Parse(ReadOnlySpan, IFormatProvider) : ParityFloat - static Parse(ReadOnlySpan, IFormatProvider) : ParityFloat - static Parse(String, IFormatProvider) : ParityFloat - static TryParse(ReadOnlySpan, IFormatProvider, out ParityFloat) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ParityFloat) : Boolean - static TryParse(String, IFormatProvider, out ParityFloat) : Boolean + static From(Single) : ParityFloat [IPlainValueObject.From] + static MaxValue : ParityFloat [IMinMaxValue.MaxValue] + static MinValue : ParityFloat [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ParityFloat [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ParityFloat [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ParityFloat [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityFloat) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityFloat) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ParityFloat) : Boolean [IParsable.TryParse] static op_Equality(ParityFloat, ParityFloat) : Boolean - static op_GreaterThan(ParityFloat, ParityFloat) : Boolean - static op_GreaterThanOrEqual(ParityFloat, ParityFloat) : Boolean + static op_GreaterThan(ParityFloat, ParityFloat) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ParityFloat, ParityFloat) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ParityFloat, ParityFloat) : Boolean - static op_LessThan(ParityFloat, ParityFloat) : Boolean - static op_LessThanOrEqual(ParityFloat, ParityFloat) : Boolean - extension static ParityFloatExtensions.GetValue(ParityFloat) : Single - extension static ParityFloatExtensions.ValueOrNull(ParityFloat?) : Single? + static op_LessThan(ParityFloat, ParityFloat) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ParityFloat, ParityFloat) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ParityFloatExtensions.GetValue(ParityFloat) : Single [IValueObject.Value] + extension static ParityFloatExtensions.ValueOrNull(ParityFloat?) : Single? [IValueObject.Value] ParityHalf - CompareTo(Object) : Int32 - CompareTo(ParityHalf) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ParityHalf) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ParityHalf) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Half + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Half [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5614,37 +5614,37 @@ ParityHalf implements IValue implements IValueObject implements IValueObjectMaterializer - nested ParityHalfJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ParityHalfTypeConverter : TypeConverter + nested ParityHalfJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ParityHalfJsonConverter] + nested ParityHalfTypeConverter : TypeConverter [IValue.ParityHalfTypeConverter] new() - static From(Half) : ParityHalf - static MaxValue : ParityHalf - static MinValue : ParityHalf - static Parse(ReadOnlySpan, IFormatProvider) : ParityHalf - static Parse(ReadOnlySpan, IFormatProvider) : ParityHalf - static Parse(String, IFormatProvider) : ParityHalf - static TryParse(ReadOnlySpan, IFormatProvider, out ParityHalf) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ParityHalf) : Boolean - static TryParse(String, IFormatProvider, out ParityHalf) : Boolean + static From(Half) : ParityHalf [IPlainValueObject.From] + static MaxValue : ParityHalf [IMinMaxValue.MaxValue] + static MinValue : ParityHalf [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ParityHalf [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ParityHalf [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ParityHalf [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityHalf) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityHalf) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ParityHalf) : Boolean [IParsable.TryParse] static op_Equality(ParityHalf, ParityHalf) : Boolean - static op_GreaterThan(ParityHalf, ParityHalf) : Boolean - static op_GreaterThanOrEqual(ParityHalf, ParityHalf) : Boolean + static op_GreaterThan(ParityHalf, ParityHalf) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ParityHalf, ParityHalf) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ParityHalf, ParityHalf) : Boolean - static op_LessThan(ParityHalf, ParityHalf) : Boolean - static op_LessThanOrEqual(ParityHalf, ParityHalf) : Boolean - extension static ParityHalfExtensions.GetValue(ParityHalf) : Half - extension static ParityHalfExtensions.ValueOrNull(ParityHalf?) : Half? + static op_LessThan(ParityHalf, ParityHalf) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ParityHalf, ParityHalf) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ParityHalfExtensions.GetValue(ParityHalf) : Half [IValueObject.Value] + extension static ParityHalfExtensions.ValueOrNull(ParityHalf?) : Half? [IValueObject.Value] ParityInt128 - CompareTo(Object) : Int32 - CompareTo(ParityInt128) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ParityInt128) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ParityInt128) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int128 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int128 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5665,37 +5665,37 @@ ParityInt128 implements IValue implements IValueObject implements IValueObjectMaterializer - nested ParityInt128JsonConverter : JsonConverter, IStoredJsonConverterSource - nested ParityInt128TypeConverter : TypeConverter + nested ParityInt128JsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ParityInt128JsonConverter] + nested ParityInt128TypeConverter : TypeConverter [IValue.ParityInt128TypeConverter] new() - static From(Int128) : ParityInt128 - static MaxValue : ParityInt128 - static MinValue : ParityInt128 - static Parse(ReadOnlySpan, IFormatProvider) : ParityInt128 - static Parse(ReadOnlySpan, IFormatProvider) : ParityInt128 - static Parse(String, IFormatProvider) : ParityInt128 - static TryParse(ReadOnlySpan, IFormatProvider, out ParityInt128) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ParityInt128) : Boolean - static TryParse(String, IFormatProvider, out ParityInt128) : Boolean + static From(Int128) : ParityInt128 [IPlainValueObject.From] + static MaxValue : ParityInt128 [IMinMaxValue.MaxValue] + static MinValue : ParityInt128 [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ParityInt128 [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ParityInt128 [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ParityInt128 [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityInt128) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityInt128) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ParityInt128) : Boolean [IParsable.TryParse] static op_Equality(ParityInt128, ParityInt128) : Boolean - static op_GreaterThan(ParityInt128, ParityInt128) : Boolean - static op_GreaterThanOrEqual(ParityInt128, ParityInt128) : Boolean + static op_GreaterThan(ParityInt128, ParityInt128) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ParityInt128, ParityInt128) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ParityInt128, ParityInt128) : Boolean - static op_LessThan(ParityInt128, ParityInt128) : Boolean - static op_LessThanOrEqual(ParityInt128, ParityInt128) : Boolean - extension static ParityInt128Extensions.GetValue(ParityInt128) : Int128 - extension static ParityInt128Extensions.ValueOrNull(ParityInt128?) : Int128? + static op_LessThan(ParityInt128, ParityInt128) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ParityInt128, ParityInt128) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ParityInt128Extensions.GetValue(ParityInt128) : Int128 [IValueObject.Value] + extension static ParityInt128Extensions.ValueOrNull(ParityInt128?) : Int128? [IValueObject.Value] ParityLong - CompareTo(Object) : Int32 - CompareTo(ParityLong) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ParityLong) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ParityLong) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int64 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int64 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5717,37 +5717,37 @@ ParityLong implements IValue implements IValueObject implements IValueObjectMaterializer - nested ParityLongJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ParityLongTypeConverter : TypeConverter + nested ParityLongJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ParityLongJsonConverter] + nested ParityLongTypeConverter : TypeConverter [IValue.ParityLongTypeConverter] new() - static From(Int64) : ParityLong - static MaxValue : ParityLong - static MinValue : ParityLong - static Parse(ReadOnlySpan, IFormatProvider) : ParityLong - static Parse(ReadOnlySpan, IFormatProvider) : ParityLong - static Parse(String, IFormatProvider) : ParityLong - static TryParse(ReadOnlySpan, IFormatProvider, out ParityLong) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ParityLong) : Boolean - static TryParse(String, IFormatProvider, out ParityLong) : Boolean + static From(Int64) : ParityLong [IPlainValueObject.From] + static MaxValue : ParityLong [IMinMaxValue.MaxValue] + static MinValue : ParityLong [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ParityLong [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ParityLong [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ParityLong [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityLong) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityLong) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ParityLong) : Boolean [IParsable.TryParse] static op_Equality(ParityLong, ParityLong) : Boolean - static op_GreaterThan(ParityLong, ParityLong) : Boolean - static op_GreaterThanOrEqual(ParityLong, ParityLong) : Boolean + static op_GreaterThan(ParityLong, ParityLong) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ParityLong, ParityLong) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ParityLong, ParityLong) : Boolean - static op_LessThan(ParityLong, ParityLong) : Boolean - static op_LessThanOrEqual(ParityLong, ParityLong) : Boolean - extension static ParityLongExtensions.GetValue(ParityLong) : Int64 - extension static ParityLongExtensions.ValueOrNull(ParityLong?) : Int64? + static op_LessThan(ParityLong, ParityLong) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ParityLong, ParityLong) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ParityLongExtensions.GetValue(ParityLong) : Int64 [IValueObject.Value] + extension static ParityLongExtensions.ValueOrNull(ParityLong?) : Int64? [IValueObject.Value] ParitySByte - CompareTo(Object) : Int32 - CompareTo(ParitySByte) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ParitySByte) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ParitySByte) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : SByte + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : SByte [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5769,37 +5769,37 @@ ParitySByte implements IValue implements IValueObject implements IValueObjectMaterializer - nested ParitySByteJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ParitySByteTypeConverter : TypeConverter + nested ParitySByteJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ParitySByteJsonConverter] + nested ParitySByteTypeConverter : TypeConverter [IValue.ParitySByteTypeConverter] new() - static From(SByte) : ParitySByte - static MaxValue : ParitySByte - static MinValue : ParitySByte - static Parse(ReadOnlySpan, IFormatProvider) : ParitySByte - static Parse(ReadOnlySpan, IFormatProvider) : ParitySByte - static Parse(String, IFormatProvider) : ParitySByte - static TryParse(ReadOnlySpan, IFormatProvider, out ParitySByte) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ParitySByte) : Boolean - static TryParse(String, IFormatProvider, out ParitySByte) : Boolean + static From(SByte) : ParitySByte [IPlainValueObject.From] + static MaxValue : ParitySByte [IMinMaxValue.MaxValue] + static MinValue : ParitySByte [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ParitySByte [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ParitySByte [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ParitySByte [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParitySByte) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParitySByte) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ParitySByte) : Boolean [IParsable.TryParse] static op_Equality(ParitySByte, ParitySByte) : Boolean - static op_GreaterThan(ParitySByte, ParitySByte) : Boolean - static op_GreaterThanOrEqual(ParitySByte, ParitySByte) : Boolean + static op_GreaterThan(ParitySByte, ParitySByte) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ParitySByte, ParitySByte) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ParitySByte, ParitySByte) : Boolean - static op_LessThan(ParitySByte, ParitySByte) : Boolean - static op_LessThanOrEqual(ParitySByte, ParitySByte) : Boolean - extension static ParitySByteExtensions.GetValue(ParitySByte) : SByte - extension static ParitySByteExtensions.ValueOrNull(ParitySByte?) : SByte? + static op_LessThan(ParitySByte, ParitySByte) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ParitySByte, ParitySByte) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ParitySByteExtensions.GetValue(ParitySByte) : SByte [IValueObject.Value] + extension static ParitySByteExtensions.ValueOrNull(ParitySByte?) : SByte? [IValueObject.Value] ParityShort - CompareTo(Object) : Int32 - CompareTo(ParityShort) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ParityShort) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ParityShort) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int16 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int16 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5821,37 +5821,37 @@ ParityShort implements IValue implements IValueObject implements IValueObjectMaterializer - nested ParityShortJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ParityShortTypeConverter : TypeConverter + nested ParityShortJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ParityShortJsonConverter] + nested ParityShortTypeConverter : TypeConverter [IValue.ParityShortTypeConverter] new() - static From(Int16) : ParityShort - static MaxValue : ParityShort - static MinValue : ParityShort - static Parse(ReadOnlySpan, IFormatProvider) : ParityShort - static Parse(ReadOnlySpan, IFormatProvider) : ParityShort - static Parse(String, IFormatProvider) : ParityShort - static TryParse(ReadOnlySpan, IFormatProvider, out ParityShort) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ParityShort) : Boolean - static TryParse(String, IFormatProvider, out ParityShort) : Boolean + static From(Int16) : ParityShort [IPlainValueObject.From] + static MaxValue : ParityShort [IMinMaxValue.MaxValue] + static MinValue : ParityShort [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ParityShort [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ParityShort [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ParityShort [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityShort) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityShort) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ParityShort) : Boolean [IParsable.TryParse] static op_Equality(ParityShort, ParityShort) : Boolean - static op_GreaterThan(ParityShort, ParityShort) : Boolean - static op_GreaterThanOrEqual(ParityShort, ParityShort) : Boolean + static op_GreaterThan(ParityShort, ParityShort) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ParityShort, ParityShort) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ParityShort, ParityShort) : Boolean - static op_LessThan(ParityShort, ParityShort) : Boolean - static op_LessThanOrEqual(ParityShort, ParityShort) : Boolean - extension static ParityShortExtensions.GetValue(ParityShort) : Int16 - extension static ParityShortExtensions.ValueOrNull(ParityShort?) : Int16? + static op_LessThan(ParityShort, ParityShort) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ParityShort, ParityShort) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ParityShortExtensions.GetValue(ParityShort) : Int16 [IValueObject.Value] + extension static ParityShortExtensions.ValueOrNull(ParityShort?) : Int16? [IValueObject.Value] ParityUInt - CompareTo(Object) : Int32 - CompareTo(ParityUInt) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ParityUInt) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ParityUInt) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : UInt32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : UInt32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5873,37 +5873,37 @@ ParityUInt implements IValue implements IValueObject implements IValueObjectMaterializer - nested ParityUIntJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ParityUIntTypeConverter : TypeConverter + nested ParityUIntJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ParityUIntJsonConverter] + nested ParityUIntTypeConverter : TypeConverter [IValue.ParityUIntTypeConverter] new() - static From(UInt32) : ParityUInt - static MaxValue : ParityUInt - static MinValue : ParityUInt - static Parse(ReadOnlySpan, IFormatProvider) : ParityUInt - static Parse(ReadOnlySpan, IFormatProvider) : ParityUInt - static Parse(String, IFormatProvider) : ParityUInt - static TryParse(ReadOnlySpan, IFormatProvider, out ParityUInt) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ParityUInt) : Boolean - static TryParse(String, IFormatProvider, out ParityUInt) : Boolean + static From(UInt32) : ParityUInt [IPlainValueObject.From] + static MaxValue : ParityUInt [IMinMaxValue.MaxValue] + static MinValue : ParityUInt [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ParityUInt [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ParityUInt [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ParityUInt [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityUInt) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityUInt) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ParityUInt) : Boolean [IParsable.TryParse] static op_Equality(ParityUInt, ParityUInt) : Boolean - static op_GreaterThan(ParityUInt, ParityUInt) : Boolean - static op_GreaterThanOrEqual(ParityUInt, ParityUInt) : Boolean + static op_GreaterThan(ParityUInt, ParityUInt) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ParityUInt, ParityUInt) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ParityUInt, ParityUInt) : Boolean - static op_LessThan(ParityUInt, ParityUInt) : Boolean - static op_LessThanOrEqual(ParityUInt, ParityUInt) : Boolean - extension static ParityUIntExtensions.GetValue(ParityUInt) : UInt32 - extension static ParityUIntExtensions.ValueOrNull(ParityUInt?) : UInt32? + static op_LessThan(ParityUInt, ParityUInt) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ParityUInt, ParityUInt) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ParityUIntExtensions.GetValue(ParityUInt) : UInt32 [IValueObject.Value] + extension static ParityUIntExtensions.ValueOrNull(ParityUInt?) : UInt32? [IValueObject.Value] ParityUInt128 - CompareTo(Object) : Int32 - CompareTo(ParityUInt128) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ParityUInt128) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ParityUInt128) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : UInt128 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : UInt128 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5924,37 +5924,37 @@ ParityUInt128 implements IValue implements IValueObject implements IValueObjectMaterializer - nested ParityUInt128JsonConverter : JsonConverter, IStoredJsonConverterSource - nested ParityUInt128TypeConverter : TypeConverter + nested ParityUInt128JsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ParityUInt128JsonConverter] + nested ParityUInt128TypeConverter : TypeConverter [IValue.ParityUInt128TypeConverter] new() - static From(UInt128) : ParityUInt128 - static MaxValue : ParityUInt128 - static MinValue : ParityUInt128 - static Parse(ReadOnlySpan, IFormatProvider) : ParityUInt128 - static Parse(ReadOnlySpan, IFormatProvider) : ParityUInt128 - static Parse(String, IFormatProvider) : ParityUInt128 - static TryParse(ReadOnlySpan, IFormatProvider, out ParityUInt128) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ParityUInt128) : Boolean - static TryParse(String, IFormatProvider, out ParityUInt128) : Boolean + static From(UInt128) : ParityUInt128 [IPlainValueObject.From] + static MaxValue : ParityUInt128 [IMinMaxValue.MaxValue] + static MinValue : ParityUInt128 [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ParityUInt128 [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ParityUInt128 [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ParityUInt128 [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityUInt128) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityUInt128) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ParityUInt128) : Boolean [IParsable.TryParse] static op_Equality(ParityUInt128, ParityUInt128) : Boolean - static op_GreaterThan(ParityUInt128, ParityUInt128) : Boolean - static op_GreaterThanOrEqual(ParityUInt128, ParityUInt128) : Boolean + static op_GreaterThan(ParityUInt128, ParityUInt128) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ParityUInt128, ParityUInt128) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ParityUInt128, ParityUInt128) : Boolean - static op_LessThan(ParityUInt128, ParityUInt128) : Boolean - static op_LessThanOrEqual(ParityUInt128, ParityUInt128) : Boolean - extension static ParityUInt128Extensions.GetValue(ParityUInt128) : UInt128 - extension static ParityUInt128Extensions.ValueOrNull(ParityUInt128?) : UInt128? + static op_LessThan(ParityUInt128, ParityUInt128) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ParityUInt128, ParityUInt128) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ParityUInt128Extensions.GetValue(ParityUInt128) : UInt128 [IValueObject.Value] + extension static ParityUInt128Extensions.ValueOrNull(ParityUInt128?) : UInt128? [IValueObject.Value] ParityULong - CompareTo(Object) : Int32 - CompareTo(ParityULong) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ParityULong) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ParityULong) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : UInt64 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : UInt64 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -5976,37 +5976,37 @@ ParityULong implements IValue implements IValueObject implements IValueObjectMaterializer - nested ParityULongJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ParityULongTypeConverter : TypeConverter + nested ParityULongJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ParityULongJsonConverter] + nested ParityULongTypeConverter : TypeConverter [IValue.ParityULongTypeConverter] new() - static From(UInt64) : ParityULong - static MaxValue : ParityULong - static MinValue : ParityULong - static Parse(ReadOnlySpan, IFormatProvider) : ParityULong - static Parse(ReadOnlySpan, IFormatProvider) : ParityULong - static Parse(String, IFormatProvider) : ParityULong - static TryParse(ReadOnlySpan, IFormatProvider, out ParityULong) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ParityULong) : Boolean - static TryParse(String, IFormatProvider, out ParityULong) : Boolean + static From(UInt64) : ParityULong [IPlainValueObject.From] + static MaxValue : ParityULong [IMinMaxValue.MaxValue] + static MinValue : ParityULong [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ParityULong [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ParityULong [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ParityULong [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityULong) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityULong) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ParityULong) : Boolean [IParsable.TryParse] static op_Equality(ParityULong, ParityULong) : Boolean - static op_GreaterThan(ParityULong, ParityULong) : Boolean - static op_GreaterThanOrEqual(ParityULong, ParityULong) : Boolean + static op_GreaterThan(ParityULong, ParityULong) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ParityULong, ParityULong) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ParityULong, ParityULong) : Boolean - static op_LessThan(ParityULong, ParityULong) : Boolean - static op_LessThanOrEqual(ParityULong, ParityULong) : Boolean - extension static ParityULongExtensions.GetValue(ParityULong) : UInt64 - extension static ParityULongExtensions.ValueOrNull(ParityULong?) : UInt64? + static op_LessThan(ParityULong, ParityULong) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ParityULong, ParityULong) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ParityULongExtensions.GetValue(ParityULong) : UInt64 [IValueObject.Value] + extension static ParityULongExtensions.ValueOrNull(ParityULong?) : UInt64? [IValueObject.Value] ParityUShort - CompareTo(Object) : Int32 - CompareTo(ParityUShort) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ParityUShort) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ParityUShort) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : UInt16 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : UInt16 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6028,37 +6028,37 @@ ParityUShort implements IValue implements IValueObject implements IValueObjectMaterializer - nested ParityUShortJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ParityUShortTypeConverter : TypeConverter + nested ParityUShortJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ParityUShortJsonConverter] + nested ParityUShortTypeConverter : TypeConverter [IValue.ParityUShortTypeConverter] new() - static From(UInt16) : ParityUShort - static MaxValue : ParityUShort - static MinValue : ParityUShort - static Parse(ReadOnlySpan, IFormatProvider) : ParityUShort - static Parse(ReadOnlySpan, IFormatProvider) : ParityUShort - static Parse(String, IFormatProvider) : ParityUShort - static TryParse(ReadOnlySpan, IFormatProvider, out ParityUShort) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ParityUShort) : Boolean - static TryParse(String, IFormatProvider, out ParityUShort) : Boolean + static From(UInt16) : ParityUShort [IPlainValueObject.From] + static MaxValue : ParityUShort [IMinMaxValue.MaxValue] + static MinValue : ParityUShort [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ParityUShort [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ParityUShort [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ParityUShort [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityUShort) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParityUShort) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ParityUShort) : Boolean [IParsable.TryParse] static op_Equality(ParityUShort, ParityUShort) : Boolean - static op_GreaterThan(ParityUShort, ParityUShort) : Boolean - static op_GreaterThanOrEqual(ParityUShort, ParityUShort) : Boolean + static op_GreaterThan(ParityUShort, ParityUShort) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ParityUShort, ParityUShort) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ParityUShort, ParityUShort) : Boolean - static op_LessThan(ParityUShort, ParityUShort) : Boolean - static op_LessThanOrEqual(ParityUShort, ParityUShort) : Boolean - extension static ParityUShortExtensions.GetValue(ParityUShort) : UInt16 - extension static ParityUShortExtensions.ValueOrNull(ParityUShort?) : UInt16? + static op_LessThan(ParityUShort, ParityUShort) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ParityUShort, ParityUShort) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ParityUShortExtensions.GetValue(ParityUShort) : UInt16 [IValueObject.Value] + extension static ParityUShortExtensions.ValueOrNull(ParityUShort?) : UInt16? [IValueObject.Value] ParseOverloadedByArity - CompareTo(Object) : Int32 - CompareTo(ParseOverloadedByArity) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ParseOverloadedByArity) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ParseOverloadedByArity) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6080,39 +6080,39 @@ ParseOverloadedByArity implements IValue implements IValueObject implements IValueObjectMaterializer - nested ParseOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ParseOverloadedByArityTypeConverter : TypeConverter + nested ParseOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ParseOverloadedByArityJsonConverter] + nested ParseOverloadedByArityTypeConverter : TypeConverter [IValue.ParseOverloadedByArityTypeConverter] new() - static From(Int32) : ParseOverloadedByArity - static MaxValue : ParseOverloadedByArity - static MinValue : ParseOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : ParseOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : ParseOverloadedByArity - static Parse(String, IFormatProvider) : ParseOverloadedByArity + static From(Int32) : ParseOverloadedByArity [IPlainValueObject.From] + static MaxValue : ParseOverloadedByArity [IMinMaxValue.MaxValue] + static MinValue : ParseOverloadedByArity [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ParseOverloadedByArity [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ParseOverloadedByArity [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ParseOverloadedByArity [IParsable.Parse] static Parse(String, IFormatProvider) : ParseOverloadedByArity - static TryParse(ReadOnlySpan, IFormatProvider, out ParseOverloadedByArity) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ParseOverloadedByArity) : Boolean - static TryParse(String, IFormatProvider, out ParseOverloadedByArity) : Boolean + static TryParse(ReadOnlySpan, IFormatProvider, out ParseOverloadedByArity) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParseOverloadedByArity) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ParseOverloadedByArity) : Boolean [IParsable.TryParse] static op_Equality(ParseOverloadedByArity, ParseOverloadedByArity) : Boolean - static op_GreaterThan(ParseOverloadedByArity, ParseOverloadedByArity) : Boolean - static op_GreaterThanOrEqual(ParseOverloadedByArity, ParseOverloadedByArity) : Boolean + static op_GreaterThan(ParseOverloadedByArity, ParseOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ParseOverloadedByArity, ParseOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ParseOverloadedByArity, ParseOverloadedByArity) : Boolean - static op_LessThan(ParseOverloadedByArity, ParseOverloadedByArity) : Boolean - static op_LessThanOrEqual(ParseOverloadedByArity, ParseOverloadedByArity) : Boolean - extension static ParseOverloadedByArityExtensions.GetValue(ParseOverloadedByArity) : Int32 - extension static ParseOverloadedByArityExtensions.ValueOrNull(ParseOverloadedByArity?) : Int32? + static op_LessThan(ParseOverloadedByArity, ParseOverloadedByArity) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ParseOverloadedByArity, ParseOverloadedByArity) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ParseOverloadedByArityExtensions.GetValue(ParseOverloadedByArity) : Int32 [IValueObject.Value] + extension static ParseOverloadedByArityExtensions.ValueOrNull(ParseOverloadedByArity?) : Int32? [IValueObject.Value] ParseOverloadedInARecordClass $() : ParseOverloadedInARecordClass - CompareTo(Object) : Int32 - CompareTo(ParseOverloadedInARecordClass) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ParseOverloadedInARecordClass) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ParseOverloadedInARecordClass) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6134,39 +6134,39 @@ ParseOverloadedInARecordClass implements IValue implements IValueObject implements IValueObjectMaterializer - nested ParseOverloadedInARecordClassJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ParseOverloadedInARecordClassTypeConverter : TypeConverter - static From(Int32) : ParseOverloadedInARecordClass - static MaxValue : ParseOverloadedInARecordClass - static MinValue : ParseOverloadedInARecordClass - static Parse(ReadOnlySpan, IFormatProvider) : ParseOverloadedInARecordClass - static Parse(ReadOnlySpan, IFormatProvider) : ParseOverloadedInARecordClass - static Parse(String, IFormatProvider) : ParseOverloadedInARecordClass + nested ParseOverloadedInARecordClassJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ParseOverloadedInARecordClassJsonConverter] + nested ParseOverloadedInARecordClassTypeConverter : TypeConverter [IValue.ParseOverloadedInARecordClassTypeConverter] + static From(Int32) : ParseOverloadedInARecordClass [IPlainValueObject.From] + static MaxValue : ParseOverloadedInARecordClass [IMinMaxValue.MaxValue] + static MinValue : ParseOverloadedInARecordClass [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : ParseOverloadedInARecordClass [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ParseOverloadedInARecordClass [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ParseOverloadedInARecordClass [IParsable.Parse] static Parse(String, IFormatProvider) : ParseOverloadedInARecordClass - static TryParse(ReadOnlySpan, IFormatProvider, out ParseOverloadedInARecordClass) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ParseOverloadedInARecordClass) : Boolean - static TryParse(String, IFormatProvider, out ParseOverloadedInARecordClass) : Boolean + static TryParse(ReadOnlySpan, IFormatProvider, out ParseOverloadedInARecordClass) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ParseOverloadedInARecordClass) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ParseOverloadedInARecordClass) : Boolean [IParsable.TryParse] static op_Equality(ParseOverloadedInARecordClass, ParseOverloadedInARecordClass) : Boolean - static op_GreaterThan(ParseOverloadedInARecordClass, ParseOverloadedInARecordClass) : Boolean - static op_GreaterThanOrEqual(ParseOverloadedInARecordClass, ParseOverloadedInARecordClass) : Boolean + static op_GreaterThan(ParseOverloadedInARecordClass, ParseOverloadedInARecordClass) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ParseOverloadedInARecordClass, ParseOverloadedInARecordClass) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ParseOverloadedInARecordClass, ParseOverloadedInARecordClass) : Boolean - static op_LessThan(ParseOverloadedInARecordClass, ParseOverloadedInARecordClass) : Boolean - static op_LessThanOrEqual(ParseOverloadedInARecordClass, ParseOverloadedInARecordClass) : Boolean - extension static ParseOverloadedInARecordClassExtensions.GetValue(ParseOverloadedInARecordClass) : Int32 - extension static ParseOverloadedInARecordClassExtensions.ValueOrNull(ParseOverloadedInARecordClass) : Int32? + static op_LessThan(ParseOverloadedInARecordClass, ParseOverloadedInARecordClass) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ParseOverloadedInARecordClass, ParseOverloadedInARecordClass) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ParseOverloadedInARecordClassExtensions.GetValue(ParseOverloadedInARecordClass) : Int32 [IValueObject.Value] + extension static ParseOverloadedInARecordClassExtensions.ValueOrNull(ParseOverloadedInARecordClass) : Int32? [IValueObject.Value] PlainOverASeamOverloadingBase $() : PlainOverASeamOverloadingBase - CompareTo(Object) : Int32 - CompareTo(PlainOverASeamOverloadingBase) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(PlainOverASeamOverloadingBase) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(PlainOverASeamOverloadingBase) : Boolean Equals(SeamOverloadingBase) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6190,38 +6190,38 @@ PlainOverASeamOverloadingBase implements IValue implements IValueObject implements IValueObjectMaterializer - nested PlainOverASeamOverloadingBaseJsonConverter : JsonConverter, IStoredJsonConverterSource - nested PlainOverASeamOverloadingBaseTypeConverter : TypeConverter - static From(Int32) : PlainOverASeamOverloadingBase - static MaxValue : PlainOverASeamOverloadingBase - static MinValue : PlainOverASeamOverloadingBase - static Parse(ReadOnlySpan, IFormatProvider) : PlainOverASeamOverloadingBase - static Parse(ReadOnlySpan, IFormatProvider) : PlainOverASeamOverloadingBase - static Parse(String, IFormatProvider) : PlainOverASeamOverloadingBase - static TryParse(ReadOnlySpan, IFormatProvider, out PlainOverASeamOverloadingBase) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out PlainOverASeamOverloadingBase) : Boolean - static TryParse(String, IFormatProvider, out PlainOverASeamOverloadingBase) : Boolean + nested PlainOverASeamOverloadingBaseJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.PlainOverASeamOverloadingBaseJsonConverter] + nested PlainOverASeamOverloadingBaseTypeConverter : TypeConverter [IValue.PlainOverASeamOverloadingBaseTypeConverter] + static From(Int32) : PlainOverASeamOverloadingBase [IPlainValueObject.From] + static MaxValue : PlainOverASeamOverloadingBase [IMinMaxValue.MaxValue] + static MinValue : PlainOverASeamOverloadingBase [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : PlainOverASeamOverloadingBase [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : PlainOverASeamOverloadingBase [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : PlainOverASeamOverloadingBase [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out PlainOverASeamOverloadingBase) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out PlainOverASeamOverloadingBase) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out PlainOverASeamOverloadingBase) : Boolean [IParsable.TryParse] static op_Equality(PlainOverASeamOverloadingBase, PlainOverASeamOverloadingBase) : Boolean - static op_GreaterThan(PlainOverASeamOverloadingBase, PlainOverASeamOverloadingBase) : Boolean - static op_GreaterThanOrEqual(PlainOverASeamOverloadingBase, PlainOverASeamOverloadingBase) : Boolean + static op_GreaterThan(PlainOverASeamOverloadingBase, PlainOverASeamOverloadingBase) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(PlainOverASeamOverloadingBase, PlainOverASeamOverloadingBase) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(PlainOverASeamOverloadingBase, PlainOverASeamOverloadingBase) : Boolean - static op_LessThan(PlainOverASeamOverloadingBase, PlainOverASeamOverloadingBase) : Boolean - static op_LessThanOrEqual(PlainOverASeamOverloadingBase, PlainOverASeamOverloadingBase) : Boolean - extension static PlainOverASeamOverloadingBaseExtensions.GetValue(PlainOverASeamOverloadingBase) : Int32 - extension static PlainOverASeamOverloadingBaseExtensions.ValueOrNull(PlainOverASeamOverloadingBase) : Int32? + static op_LessThan(PlainOverASeamOverloadingBase, PlainOverASeamOverloadingBase) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(PlainOverASeamOverloadingBase, PlainOverASeamOverloadingBase) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static PlainOverASeamOverloadingBaseExtensions.GetValue(PlainOverASeamOverloadingBase) : Int32 [IValueObject.Value] + extension static PlainOverASeamOverloadingBaseExtensions.ValueOrNull(PlainOverASeamOverloadingBase) : Int32? [IValueObject.Value] PrintMembersOverloadedByArity $() : PrintMembersOverloadedByArity - CompareTo(Object) : Int32 - CompareTo(PrintMembersOverloadedByArity) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(PrintMembersOverloadedByArity) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(PrintMembersOverloadedByArity) : Boolean GetHashCode() : Int32 PrintMembers(StringBuilder) : Boolean ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6243,36 +6243,36 @@ PrintMembersOverloadedByArity implements IValue implements IValueObject implements IValueObjectMaterializer - nested PrintMembersOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource - nested PrintMembersOverloadedByArityTypeConverter : TypeConverter - static From(Int32) : PrintMembersOverloadedByArity - static MaxValue : PrintMembersOverloadedByArity - static MinValue : PrintMembersOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : PrintMembersOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : PrintMembersOverloadedByArity - static Parse(String, IFormatProvider) : PrintMembersOverloadedByArity - static TryParse(ReadOnlySpan, IFormatProvider, out PrintMembersOverloadedByArity) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out PrintMembersOverloadedByArity) : Boolean - static TryParse(String, IFormatProvider, out PrintMembersOverloadedByArity) : Boolean + nested PrintMembersOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.PrintMembersOverloadedByArityJsonConverter] + nested PrintMembersOverloadedByArityTypeConverter : TypeConverter [IValue.PrintMembersOverloadedByArityTypeConverter] + static From(Int32) : PrintMembersOverloadedByArity [IPlainValueObject.From] + static MaxValue : PrintMembersOverloadedByArity [IMinMaxValue.MaxValue] + static MinValue : PrintMembersOverloadedByArity [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : PrintMembersOverloadedByArity [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : PrintMembersOverloadedByArity [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : PrintMembersOverloadedByArity [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out PrintMembersOverloadedByArity) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out PrintMembersOverloadedByArity) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out PrintMembersOverloadedByArity) : Boolean [IParsable.TryParse] static op_Equality(PrintMembersOverloadedByArity, PrintMembersOverloadedByArity) : Boolean - static op_GreaterThan(PrintMembersOverloadedByArity, PrintMembersOverloadedByArity) : Boolean - static op_GreaterThanOrEqual(PrintMembersOverloadedByArity, PrintMembersOverloadedByArity) : Boolean + static op_GreaterThan(PrintMembersOverloadedByArity, PrintMembersOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(PrintMembersOverloadedByArity, PrintMembersOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(PrintMembersOverloadedByArity, PrintMembersOverloadedByArity) : Boolean - static op_LessThan(PrintMembersOverloadedByArity, PrintMembersOverloadedByArity) : Boolean - static op_LessThanOrEqual(PrintMembersOverloadedByArity, PrintMembersOverloadedByArity) : Boolean - extension static PrintMembersOverloadedByArityExtensions.GetValue(PrintMembersOverloadedByArity) : Int32 - extension static PrintMembersOverloadedByArityExtensions.ValueOrNull(PrintMembersOverloadedByArity) : Int32? + static op_LessThan(PrintMembersOverloadedByArity, PrintMembersOverloadedByArity) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(PrintMembersOverloadedByArity, PrintMembersOverloadedByArity) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static PrintMembersOverloadedByArityExtensions.GetValue(PrintMembersOverloadedByArity) : Int32 [IValueObject.Value] + extension static PrintMembersOverloadedByArityExtensions.ValueOrNull(PrintMembersOverloadedByArity) : Int32? [IValueObject.Value] RoundedMoney - CompareTo(Object) : Int32 - CompareTo(RoundedMoney) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(RoundedMoney) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(RoundedMoney) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Decimal + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Decimal [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6296,40 +6296,40 @@ RoundedMoney implements IValue implements IValueObject implements IValueObjectMaterializer - nested RoundedMoneyJsonConverter : JsonConverter, IStoredJsonConverterSource - nested RoundedMoneyTypeConverter : TypeConverter + nested RoundedMoneyJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.RoundedMoneyJsonConverter] + nested RoundedMoneyTypeConverter : TypeConverter [IValue.RoundedMoneyTypeConverter] new() - static From(Decimal) : RoundedMoney - static MaxValue : RoundedMoney - static MinValue : RoundedMoney - static Parse(ReadOnlySpan, IFormatProvider) : RoundedMoney - static Parse(ReadOnlySpan, IFormatProvider) : RoundedMoney - static Parse(String, IFormatProvider) : RoundedMoney - static TryParse(ReadOnlySpan, IFormatProvider, out RoundedMoney) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out RoundedMoney) : Boolean - static TryParse(String, IFormatProvider, out RoundedMoney) : Boolean + static From(Decimal) : RoundedMoney [IPlainValueObject.From] + static MaxValue : RoundedMoney [IMinMaxValue.MaxValue] + static MinValue : RoundedMoney [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : RoundedMoney [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : RoundedMoney [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : RoundedMoney [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out RoundedMoney) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out RoundedMoney) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out RoundedMoney) : Boolean [IParsable.TryParse] static op_Addition(RoundedMoney, RoundedMoney) : RoundedMoney - static op_CheckedSubtraction(RoundedMoney, RoundedMoney) : RoundedMoney + static op_CheckedSubtraction(RoundedMoney, RoundedMoney) : RoundedMoney [ISubtractionOperators.op_CheckedSubtraction] static op_Equality(RoundedMoney, RoundedMoney) : Boolean - static op_GreaterThan(RoundedMoney, RoundedMoney) : Boolean - static op_GreaterThanOrEqual(RoundedMoney, RoundedMoney) : Boolean + static op_GreaterThan(RoundedMoney, RoundedMoney) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(RoundedMoney, RoundedMoney) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(RoundedMoney, RoundedMoney) : Boolean - static op_LessThan(RoundedMoney, RoundedMoney) : Boolean - static op_LessThanOrEqual(RoundedMoney, RoundedMoney) : Boolean - static op_Subtraction(RoundedMoney, RoundedMoney) : RoundedMoney - extension static RoundedMoneyExtensions.GetValue(RoundedMoney) : Decimal - extension static RoundedMoneyExtensions.ValueOrNull(RoundedMoney?) : Decimal? + static op_LessThan(RoundedMoney, RoundedMoney) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(RoundedMoney, RoundedMoney) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Subtraction(RoundedMoney, RoundedMoney) : RoundedMoney [ISubtractionOperators.op_Subtraction] + extension static RoundedMoneyExtensions.GetValue(RoundedMoney) : Decimal [IValueObject.Value] + extension static RoundedMoneyExtensions.ValueOrNull(RoundedMoney?) : Decimal? [IValueObject.Value] SByteAmount - CompareTo(Object) : Int32 - CompareTo(SByteAmount) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(SByteAmount) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(SByteAmount) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : SByte + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : SByte [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6359,50 +6359,50 @@ SByteAmount implements IValue implements IValueObject implements IValueObjectMaterializer - nested SByteAmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested SByteAmountTypeConverter : TypeConverter + nested SByteAmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.SByteAmountJsonConverter] + nested SByteAmountTypeConverter : TypeConverter [IValue.SByteAmountTypeConverter] new() - static From(SByte) : SByteAmount - static MaxValue : SByteAmount - static MinValue : SByteAmount - static Parse(ReadOnlySpan, IFormatProvider) : SByteAmount - static Parse(ReadOnlySpan, IFormatProvider) : SByteAmount - static Parse(String, IFormatProvider) : SByteAmount - static TryParse(ReadOnlySpan, IFormatProvider, out SByteAmount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out SByteAmount) : Boolean - static TryParse(String, IFormatProvider, out SByteAmount) : Boolean - static op_Addition(SByteAmount, SByteAmount) : SByteAmount - static op_CheckedAddition(SByteAmount, SByteAmount) : SByteAmount - static op_CheckedDivision(SByteAmount, SByteAmount) : SByteAmount - static op_CheckedMultiply(SByteAmount, SByteAmount) : SByteAmount - static op_CheckedSubtraction(SByteAmount, SByteAmount) : SByteAmount - static op_CheckedUnaryNegation(SByteAmount) : SByteAmount - static op_Division(SByteAmount, SByteAmount) : SByteAmount + static From(SByte) : SByteAmount [IPlainValueObject.From] + static MaxValue : SByteAmount [IMinMaxValue.MaxValue] + static MinValue : SByteAmount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : SByteAmount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : SByteAmount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : SByteAmount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out SByteAmount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out SByteAmount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out SByteAmount) : Boolean [IParsable.TryParse] + static op_Addition(SByteAmount, SByteAmount) : SByteAmount [IAdditionOperators.op_Addition] + static op_CheckedAddition(SByteAmount, SByteAmount) : SByteAmount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(SByteAmount, SByteAmount) : SByteAmount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(SByteAmount, SByteAmount) : SByteAmount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(SByteAmount, SByteAmount) : SByteAmount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(SByteAmount) : SByteAmount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(SByteAmount, SByteAmount) : SByteAmount [IDivisionOperators.op_Division] static op_Equality(SByteAmount, SByteAmount) : Boolean - static op_GreaterThan(SByteAmount, SByteAmount) : Boolean - static op_GreaterThanOrEqual(SByteAmount, SByteAmount) : Boolean + static op_GreaterThan(SByteAmount, SByteAmount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(SByteAmount, SByteAmount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(SByteAmount, SByteAmount) : Boolean - static op_LessThan(SByteAmount, SByteAmount) : Boolean - static op_LessThanOrEqual(SByteAmount, SByteAmount) : Boolean - static op_Modulus(SByteAmount, SByteAmount) : SByteAmount - static op_Multiply(SByteAmount, SByteAmount) : SByteAmount - static op_Subtraction(SByteAmount, SByteAmount) : SByteAmount - static op_UnaryNegation(SByteAmount) : SByteAmount - static op_UnaryPlus(SByteAmount) : SByteAmount - extension static SByteAmountExtensions.GetValue(SByteAmount) : SByte - extension static SByteAmountExtensions.ValueOrNull(SByteAmount?) : SByte? + static op_LessThan(SByteAmount, SByteAmount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(SByteAmount, SByteAmount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(SByteAmount, SByteAmount) : SByteAmount [IModulusOperators.op_Modulus] + static op_Multiply(SByteAmount, SByteAmount) : SByteAmount [IMultiplyOperators.op_Multiply] + static op_Subtraction(SByteAmount, SByteAmount) : SByteAmount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(SByteAmount) : SByteAmount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(SByteAmount) : SByteAmount [IUnaryPlusOperators.op_UnaryPlus] + extension static SByteAmountExtensions.GetValue(SByteAmount) : SByte [IValueObject.Value] + extension static SByteAmountExtensions.ValueOrNull(SByteAmount?) : SByte? [IValueObject.Value] Score - CompareTo(Object) : Int32 - CompareTo(Score) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(Score) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(Score) : Boolean GetHashCode() : Int32 - Revalidate() : Result + Revalidate() : Result [IValidatedValue.Revalidate] ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6423,68 +6423,68 @@ Score implements IValidatedValue implements IValueObject implements IValueObjectMaterializer - nested ScoreJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ScoreTypeConverter : TypeConverter + nested ScoreJsonConverter : JsonConverter, IStoredJsonConverterSource [IValidatedValue.ScoreJsonConverter] + nested ScoreTypeConverter : TypeConverter [IValidatedValue.ScoreTypeConverter] new() static Create(Int32) : Result - static FromKnownGood(Int32, String) : Score - static Parse(ReadOnlySpan, IFormatProvider) : Score - static Parse(ReadOnlySpan, IFormatProvider) : Score - static Parse(String, IFormatProvider) : Score - static TryFrom(Int32) : Option - static TryParse(ReadOnlySpan, IFormatProvider, out Score) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out Score) : Boolean - static TryParse(String, IFormatProvider, out Score) : Boolean + static FromKnownGood(Int32, String) : Score [IValidatedValue.FromKnownGood] + static Parse(ReadOnlySpan, IFormatProvider) : Score [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : Score [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : Score [IParsable.Parse] + static TryFrom(Int32) : Option [IValidatedValue.TryFrom] + static TryParse(ReadOnlySpan, IFormatProvider, out Score) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out Score) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out Score) : Boolean [IParsable.TryParse] static op_Addition(Score, Score) : Score static op_Equality(Score, Score) : Boolean - static op_GreaterThan(Score, Score) : Boolean - static op_GreaterThanOrEqual(Score, Score) : Boolean + static op_GreaterThan(Score, Score) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(Score, Score) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(Score, Score) : Boolean - static op_LessThan(Score, Score) : Boolean - static op_LessThanOrEqual(Score, Score) : Boolean - extension static ScoreExtensions.GetValue(Score) : Int32 - extension static ScoreExtensions.ValueOrNull(Score?) : Int32? + static op_LessThan(Score, Score) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(Score, Score) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ScoreExtensions.GetValue(Score) : Int32 [IValueObject.Value] + extension static ScoreExtensions.ValueOrNull(Score?) : Int32? [IValueObject.Value] SetOverAnOverloadingBase - Match(Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested SetOverAnOverloadingBaseJsonConverter : JsonConverter - nested SetOverAnOverloadingBaseTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : SetOverAnOverloadingBase - static Parse(String, Boolean) : SetOverAnOverloadingBase - static TryParse(String, Boolean, out SetOverAnOverloadingBase) : Boolean - static TryParse(String, out SetOverAnOverloadingBase) : Boolean + nested SetOverAnOverloadingBaseJsonConverter : JsonConverter [IClosedSet.SetOverAnOverloadingBaseJsonConverter] + nested SetOverAnOverloadingBaseTypeConverter : TypeConverter [IClosedSet.SetOverAnOverloadingBaseTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : SetOverAnOverloadingBase [IClosedSet.Parse] + static Parse(String, Boolean) : SetOverAnOverloadingBase [IClosedSet.Parse] + static TryParse(String, Boolean, out SetOverAnOverloadingBase) : Boolean [IClosedSet.TryParse] + static TryParse(String, out SetOverAnOverloadingBase) : Boolean [IClosedSet.TryParse] SetOverPrivateNames - Match(Func, Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func, Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute attribute JsonConverterAttribute attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested SetOverPrivateNamesJsonConverter : JsonConverter - nested SetOverPrivateNamesTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : SetOverPrivateNames - static Parse(String, Boolean) : SetOverPrivateNames - static TryParse(String, Boolean, out SetOverPrivateNames) : Boolean - static TryParse(String, out SetOverPrivateNames) : Boolean + nested SetOverPrivateNamesJsonConverter : JsonConverter [IClosedSet.SetOverPrivateNamesJsonConverter] + nested SetOverPrivateNamesTypeConverter : TypeConverter [IClosedSet.SetOverPrivateNamesTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : SetOverPrivateNames [IClosedSet.Parse] + static Parse(String, Boolean) : SetOverPrivateNames [IClosedSet.Parse] + static TryParse(String, Boolean, out SetOverPrivateNames) : Boolean [IClosedSet.TryParse] + static TryParse(String, out SetOverPrivateNames) : Boolean [IClosedSet.TryParse] SetWithAGenericToString - Match(Func) : TResult - Name : String - QualifiedName : String - ToString() : String + Match(Func) : TResult [IClosedSet.Match] + Name : String [IClosedSet.Name] + QualifiedName : String [IClosedSet.QualifiedName] + ToString() : String [IClosedSet.ToString] ToString() : String attribute CompilerGeneratedAttribute attribute GeneratedClosedSetAttribute @@ -6492,21 +6492,21 @@ SetWithAGenericToString attribute TypeConverterAttribute implements IClosedSet implements IParsable - nested SetWithAGenericToStringJsonConverter : JsonConverter - nested SetWithAGenericToStringTypeConverter : TypeConverter - static All : IReadOnlyList - static Parse(String) : SetWithAGenericToString - static Parse(String, Boolean) : SetWithAGenericToString - static TryParse(String, Boolean, out SetWithAGenericToString) : Boolean - static TryParse(String, out SetWithAGenericToString) : Boolean + nested SetWithAGenericToStringJsonConverter : JsonConverter [IClosedSet.SetWithAGenericToStringJsonConverter] + nested SetWithAGenericToStringTypeConverter : TypeConverter [IClosedSet.SetWithAGenericToStringTypeConverter] + static All : IReadOnlyList [IClosedSet.All] + static Parse(String) : SetWithAGenericToString [IClosedSet.Parse] + static Parse(String, Boolean) : SetWithAGenericToString [IClosedSet.Parse] + static TryParse(String, Boolean, out SetWithAGenericToString) : Boolean [IClosedSet.TryParse] + static TryParse(String, out SetWithAGenericToString) : Boolean [IClosedSet.TryParse] ShippableStatus Equals(Object) : Boolean Equals(ShippableStatus) : Boolean GetHashCode() : Int32 - Revalidate() : Result + Revalidate() : Result [IValidatedValue.Revalidate] ToString() : String - ToString(String, IFormatProvider) : String - Value : LocalStatus + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : LocalStatus [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6518,29 +6518,29 @@ ShippableStatus implements IValidatedValue implements IValueObject implements IValueObjectMaterializer - nested ShippableStatusJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ShippableStatusTypeConverter : TypeConverter + nested ShippableStatusJsonConverter : JsonConverter, IStoredJsonConverterSource [IValidatedValue.ShippableStatusJsonConverter] + nested ShippableStatusTypeConverter : TypeConverter [IValidatedValue.ShippableStatusTypeConverter] new() static Create(LocalStatus) : Result - static FromKnownGood(LocalStatus, String) : ShippableStatus - static Parse(String, IFormatProvider) : ShippableStatus - static TryFrom(LocalStatus) : Option - static TryParse(String, IFormatProvider, out ShippableStatus) : Boolean + static FromKnownGood(LocalStatus, String) : ShippableStatus [IValidatedValue.FromKnownGood] + static Parse(String, IFormatProvider) : ShippableStatus [IParsable.Parse] + static TryFrom(LocalStatus) : Option [IValidatedValue.TryFrom] + static TryParse(String, IFormatProvider, out ShippableStatus) : Boolean [IParsable.TryParse] static op_Equality(ShippableStatus, ShippableStatus) : Boolean static op_Inequality(ShippableStatus, ShippableStatus) : Boolean - extension static ShippableStatusExtensions.GetValue(ShippableStatus) : LocalStatus - extension static ShippableStatusExtensions.ValueOrNull(ShippableStatus?) : LocalStatus + extension static ShippableStatusExtensions.GetValue(ShippableStatus) : LocalStatus [IValueObject.Value] + extension static ShippableStatusExtensions.ValueOrNull(ShippableStatus?) : LocalStatus [IValueObject.Value] SingleAmount - CompareTo(Object) : Int32 - CompareTo(SingleAmount) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(SingleAmount) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(SingleAmount) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Single + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Single [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6570,49 +6570,49 @@ SingleAmount implements IValue implements IValueObject implements IValueObjectMaterializer - nested SingleAmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested SingleAmountTypeConverter : TypeConverter + nested SingleAmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.SingleAmountJsonConverter] + nested SingleAmountTypeConverter : TypeConverter [IValue.SingleAmountTypeConverter] new() - static From(Single) : SingleAmount - static MaxValue : SingleAmount - static MinValue : SingleAmount - static Parse(ReadOnlySpan, IFormatProvider) : SingleAmount - static Parse(ReadOnlySpan, IFormatProvider) : SingleAmount - static Parse(String, IFormatProvider) : SingleAmount - static TryParse(ReadOnlySpan, IFormatProvider, out SingleAmount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out SingleAmount) : Boolean - static TryParse(String, IFormatProvider, out SingleAmount) : Boolean - static op_Addition(SingleAmount, SingleAmount) : SingleAmount - static op_CheckedAddition(SingleAmount, SingleAmount) : SingleAmount - static op_CheckedDivision(SingleAmount, SingleAmount) : SingleAmount - static op_CheckedMultiply(SingleAmount, SingleAmount) : SingleAmount - static op_CheckedSubtraction(SingleAmount, SingleAmount) : SingleAmount - static op_CheckedUnaryNegation(SingleAmount) : SingleAmount - static op_Division(SingleAmount, SingleAmount) : SingleAmount + static From(Single) : SingleAmount [IPlainValueObject.From] + static MaxValue : SingleAmount [IMinMaxValue.MaxValue] + static MinValue : SingleAmount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : SingleAmount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : SingleAmount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : SingleAmount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out SingleAmount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out SingleAmount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out SingleAmount) : Boolean [IParsable.TryParse] + static op_Addition(SingleAmount, SingleAmount) : SingleAmount [IAdditionOperators.op_Addition] + static op_CheckedAddition(SingleAmount, SingleAmount) : SingleAmount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(SingleAmount, SingleAmount) : SingleAmount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(SingleAmount, SingleAmount) : SingleAmount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(SingleAmount, SingleAmount) : SingleAmount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(SingleAmount) : SingleAmount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(SingleAmount, SingleAmount) : SingleAmount [IDivisionOperators.op_Division] static op_Equality(SingleAmount, SingleAmount) : Boolean - static op_GreaterThan(SingleAmount, SingleAmount) : Boolean - static op_GreaterThanOrEqual(SingleAmount, SingleAmount) : Boolean + static op_GreaterThan(SingleAmount, SingleAmount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(SingleAmount, SingleAmount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(SingleAmount, SingleAmount) : Boolean - static op_LessThan(SingleAmount, SingleAmount) : Boolean - static op_LessThanOrEqual(SingleAmount, SingleAmount) : Boolean - static op_Modulus(SingleAmount, SingleAmount) : SingleAmount - static op_Multiply(SingleAmount, SingleAmount) : SingleAmount - static op_Subtraction(SingleAmount, SingleAmount) : SingleAmount - static op_UnaryNegation(SingleAmount) : SingleAmount - static op_UnaryPlus(SingleAmount) : SingleAmount - extension static SingleAmountExtensions.GetValue(SingleAmount) : Single - extension static SingleAmountExtensions.ValueOrNull(SingleAmount?) : Single? + static op_LessThan(SingleAmount, SingleAmount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(SingleAmount, SingleAmount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(SingleAmount, SingleAmount) : SingleAmount [IModulusOperators.op_Modulus] + static op_Multiply(SingleAmount, SingleAmount) : SingleAmount [IMultiplyOperators.op_Multiply] + static op_Subtraction(SingleAmount, SingleAmount) : SingleAmount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(SingleAmount) : SingleAmount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(SingleAmount) : SingleAmount [IUnaryPlusOperators.op_UnaryPlus] + extension static SingleAmountExtensions.GetValue(SingleAmount) : Single [IValueObject.Value] + extension static SingleAmountExtensions.ValueOrNull(SingleAmount?) : Single? [IValueObject.Value] SpanParseOverloaded - CompareTo(Object) : Int32 - CompareTo(SpanParseOverloaded) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(SpanParseOverloaded) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(SpanParseOverloaded) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6634,35 +6634,35 @@ SpanParseOverloaded implements IValue implements IValueObject implements IValueObjectMaterializer - nested SpanParseOverloadedJsonConverter : JsonConverter, IStoredJsonConverterSource - nested SpanParseOverloadedTypeConverter : TypeConverter + nested SpanParseOverloadedJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.SpanParseOverloadedJsonConverter] + nested SpanParseOverloadedTypeConverter : TypeConverter [IValue.SpanParseOverloadedTypeConverter] new() - static From(Int32) : SpanParseOverloaded - static MaxValue : SpanParseOverloaded - static MinValue : SpanParseOverloaded - static Parse(ReadOnlySpan, IFormatProvider) : SpanParseOverloaded - static Parse(ReadOnlySpan, IFormatProvider) : SpanParseOverloaded - static Parse(String, IFormatProvider) : SpanParseOverloaded + static From(Int32) : SpanParseOverloaded [IPlainValueObject.From] + static MaxValue : SpanParseOverloaded [IMinMaxValue.MaxValue] + static MinValue : SpanParseOverloaded [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : SpanParseOverloaded [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : SpanParseOverloaded [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : SpanParseOverloaded [IParsable.Parse] static Parse(ReadOnlySpan, IFormatProvider) : SpanParseOverloaded - static TryParse(ReadOnlySpan, IFormatProvider, out SpanParseOverloaded) : Boolean + static TryParse(ReadOnlySpan, IFormatProvider, out SpanParseOverloaded) : Boolean [IUtf8SpanParsable.TryParse] static TryParse(ReadOnlySpan, IFormatProvider, SpanParseOverloaded) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out SpanParseOverloaded) : Boolean - static TryParse(String, IFormatProvider, out SpanParseOverloaded) : Boolean + static TryParse(ReadOnlySpan, IFormatProvider, out SpanParseOverloaded) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out SpanParseOverloaded) : Boolean [IParsable.TryParse] static op_Equality(SpanParseOverloaded, SpanParseOverloaded) : Boolean - static op_GreaterThan(SpanParseOverloaded, SpanParseOverloaded) : Boolean - static op_GreaterThanOrEqual(SpanParseOverloaded, SpanParseOverloaded) : Boolean + static op_GreaterThan(SpanParseOverloaded, SpanParseOverloaded) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(SpanParseOverloaded, SpanParseOverloaded) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(SpanParseOverloaded, SpanParseOverloaded) : Boolean - static op_LessThan(SpanParseOverloaded, SpanParseOverloaded) : Boolean - static op_LessThanOrEqual(SpanParseOverloaded, SpanParseOverloaded) : Boolean - extension static SpanParseOverloadedExtensions.GetValue(SpanParseOverloaded) : Int32 - extension static SpanParseOverloadedExtensions.ValueOrNull(SpanParseOverloaded?) : Int32? + static op_LessThan(SpanParseOverloaded, SpanParseOverloaded) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(SpanParseOverloaded, SpanParseOverloaded) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static SpanParseOverloadedExtensions.GetValue(SpanParseOverloaded) : Int32 [IValueObject.Value] + extension static SpanParseOverloadedExtensions.ValueOrNull(SpanParseOverloaded?) : Int32? [IValueObject.Value] StageOfOrder Equals(Object) : Boolean Equals(StageOfOrder) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : LocalOrder.Stage + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : LocalOrder.Stage [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6675,23 +6675,23 @@ StageOfOrder implements IValue implements IValueObject implements IValueObjectMaterializer - nested StageOfOrderJsonConverter : JsonConverter, IStoredJsonConverterSource - nested StageOfOrderTypeConverter : TypeConverter + nested StageOfOrderJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.StageOfOrderJsonConverter] + nested StageOfOrderTypeConverter : TypeConverter [IValue.StageOfOrderTypeConverter] new() - static From(LocalOrder.Stage) : StageOfOrder - static Parse(String, IFormatProvider) : StageOfOrder - static TryParse(String, IFormatProvider, out StageOfOrder) : Boolean + static From(LocalOrder.Stage) : StageOfOrder [IPlainValueObject.From] + static Parse(String, IFormatProvider) : StageOfOrder [IParsable.Parse] + static TryParse(String, IFormatProvider, out StageOfOrder) : Boolean [IParsable.TryParse] static op_Equality(StageOfOrder, StageOfOrder) : Boolean static op_Inequality(StageOfOrder, StageOfOrder) : Boolean - extension static StageOfOrderExtensions.GetValue(StageOfOrder) : LocalOrder.Stage - extension static StageOfOrderExtensions.ValueOrNull(StageOfOrder?) : LocalOrder.Stage + extension static StageOfOrderExtensions.GetValue(StageOfOrder) : LocalOrder.Stage [IValueObject.Value] + extension static StageOfOrderExtensions.ValueOrNull(StageOfOrder?) : LocalOrder.Stage [IValueObject.Value] Stamp Equals(Object) : Boolean Equals(Stamp) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : Tick + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : Tick [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6704,25 +6704,25 @@ Stamp implements IValue implements IValueObject implements IValueObjectMaterializer - nested StampJsonConverter : JsonConverter, IStoredJsonConverterSource + nested StampJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.StampJsonConverter] new() - static From(Tick) : Stamp - static op_Addition(Stamp, Elapsed) : Stamp - static op_CheckedAddition(Stamp, Elapsed) : Stamp - static op_CheckedSubtraction(Stamp, Stamp) : Elapsed + static From(Tick) : Stamp [IPlainValueObject.From] + static op_Addition(Stamp, Elapsed) : Stamp [IAdditionOperators.op_Addition] + static op_CheckedAddition(Stamp, Elapsed) : Stamp [IAdditionOperators.op_CheckedAddition] + static op_CheckedSubtraction(Stamp, Stamp) : Elapsed [ISubtractionOperators.op_CheckedSubtraction] static op_Equality(Stamp, Stamp) : Boolean static op_Inequality(Stamp, Stamp) : Boolean - static op_Subtraction(Stamp, Stamp) : Elapsed - extension static StampExtensions.GetValue(Stamp) : Tick - extension static StampExtensions.ValueOrNull(Stamp?) : Tick? + static op_Subtraction(Stamp, Stamp) : Elapsed [ISubtractionOperators.op_Subtraction] + extension static StampExtensions.GetValue(Stamp) : Tick [IValueObject.Value] + extension static StampExtensions.ValueOrNull(Stamp?) : Tick? [IValueObject.Value] StatusLabel $() : StatusLabel Equals(Object) : Boolean Equals(StatusLabel) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : LocalStatus + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : LocalStatus [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6735,22 +6735,22 @@ StatusLabel implements IValue implements IValueObject implements IValueObjectMaterializer - nested StatusLabelJsonConverter : JsonConverter, IStoredJsonConverterSource - nested StatusLabelTypeConverter : TypeConverter - static From(LocalStatus) : StatusLabel - static Parse(String, IFormatProvider) : StatusLabel - static TryParse(String, IFormatProvider, out StatusLabel) : Boolean + nested StatusLabelJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.StatusLabelJsonConverter] + nested StatusLabelTypeConverter : TypeConverter [IValue.StatusLabelTypeConverter] + static From(LocalStatus) : StatusLabel [IPlainValueObject.From] + static Parse(String, IFormatProvider) : StatusLabel [IParsable.Parse] + static TryParse(String, IFormatProvider, out StatusLabel) : Boolean [IParsable.TryParse] static op_Equality(StatusLabel, StatusLabel) : Boolean static op_Inequality(StatusLabel, StatusLabel) : Boolean - extension static StatusLabelExtensions.GetValue(StatusLabel) : LocalStatus - extension static StatusLabelExtensions.ValueOrNull(StatusLabel) : LocalStatus + extension static StatusLabelExtensions.GetValue(StatusLabel) : LocalStatus [IValueObject.Value] + extension static StatusLabelExtensions.ValueOrNull(StatusLabel) : LocalStatus [IValueObject.Value] StatusOfOrder Equals(Object) : Boolean Equals(StatusOfOrder) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - Value : LocalStatus + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : LocalStatus [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6763,27 +6763,27 @@ StatusOfOrder implements IValue implements IValueObject implements IValueObjectMaterializer - nested StatusOfOrderJsonConverter : JsonConverter, IStoredJsonConverterSource - nested StatusOfOrderTypeConverter : TypeConverter + nested StatusOfOrderJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.StatusOfOrderJsonConverter] + nested StatusOfOrderTypeConverter : TypeConverter [IValue.StatusOfOrderTypeConverter] new() - static From(LocalStatus) : StatusOfOrder - static Parse(String, IFormatProvider) : StatusOfOrder - static TryParse(String, IFormatProvider, out StatusOfOrder) : Boolean + static From(LocalStatus) : StatusOfOrder [IPlainValueObject.From] + static Parse(String, IFormatProvider) : StatusOfOrder [IParsable.Parse] + static TryParse(String, IFormatProvider, out StatusOfOrder) : Boolean [IParsable.TryParse] static op_Equality(StatusOfOrder, StatusOfOrder) : Boolean static op_Inequality(StatusOfOrder, StatusOfOrder) : Boolean - extension static StatusOfOrderExtensions.GetValue(StatusOfOrder) : LocalStatus - extension static StatusOfOrderExtensions.ValueOrNull(StatusOfOrder?) : LocalStatus + extension static StatusOfOrderExtensions.GetValue(StatusOfOrder) : LocalStatus [IValueObject.Value] + extension static StatusOfOrderExtensions.ValueOrNull(StatusOfOrder?) : LocalStatus [IValueObject.Value] TestForeignIdentifier - CompareTo(Object) : Int32 - CompareTo(TestForeignIdentifier) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(TestForeignIdentifier) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(TestForeignIdentifier) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Guid + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Guid [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6804,35 +6804,35 @@ TestForeignIdentifier implements IValue implements IValueObject implements IValueObjectMaterializer - nested TestForeignIdentifierJsonConverter : JsonConverter, IStoredJsonConverterSource - nested TestForeignIdentifierTypeConverter : TypeConverter + nested TestForeignIdentifierJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.TestForeignIdentifierJsonConverter] + nested TestForeignIdentifierTypeConverter : TypeConverter [IValue.TestForeignIdentifierTypeConverter] new() - static From(Guid) : TestForeignIdentifier - static Parse(ReadOnlySpan, IFormatProvider) : TestForeignIdentifier - static Parse(ReadOnlySpan, IFormatProvider) : TestForeignIdentifier - static Parse(String, IFormatProvider) : TestForeignIdentifier - static TryParse(ReadOnlySpan, IFormatProvider, out TestForeignIdentifier) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out TestForeignIdentifier) : Boolean - static TryParse(String, IFormatProvider, out TestForeignIdentifier) : Boolean + static From(Guid) : TestForeignIdentifier [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : TestForeignIdentifier [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : TestForeignIdentifier [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : TestForeignIdentifier [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out TestForeignIdentifier) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out TestForeignIdentifier) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out TestForeignIdentifier) : Boolean [IParsable.TryParse] static op_Equality(TestForeignIdentifier, TestForeignIdentifier) : Boolean - static op_GreaterThan(TestForeignIdentifier, TestForeignIdentifier) : Boolean - static op_GreaterThanOrEqual(TestForeignIdentifier, TestForeignIdentifier) : Boolean + static op_GreaterThan(TestForeignIdentifier, TestForeignIdentifier) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(TestForeignIdentifier, TestForeignIdentifier) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(TestForeignIdentifier, TestForeignIdentifier) : Boolean - static op_LessThan(TestForeignIdentifier, TestForeignIdentifier) : Boolean - static op_LessThanOrEqual(TestForeignIdentifier, TestForeignIdentifier) : Boolean - extension static TestForeignIdentifierExtensions.GetValue(TestForeignIdentifier) : Guid - extension static TestForeignIdentifierExtensions.ValueOrNull(TestForeignIdentifier?) : Guid? + static op_LessThan(TestForeignIdentifier, TestForeignIdentifier) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(TestForeignIdentifier, TestForeignIdentifier) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static TestForeignIdentifierExtensions.GetValue(TestForeignIdentifier) : Guid [IValueObject.Value] + extension static TestForeignIdentifierExtensions.ValueOrNull(TestForeignIdentifier?) : Guid? [IValueObject.Value] TestLocalId - CompareTo(Object) : Int32 - CompareTo(TestLocalId) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(TestLocalId) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(TestLocalId) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6854,38 +6854,38 @@ TestLocalId implements IValue implements IValueObject implements IValueObjectMaterializer - nested TestLocalIdJsonConverter : JsonConverter, IStoredJsonConverterSource - nested TestLocalIdTypeConverter : TypeConverter + nested TestLocalIdJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.TestLocalIdJsonConverter] + nested TestLocalIdTypeConverter : TypeConverter [IValue.TestLocalIdTypeConverter] new() - static From(Int32) : TestLocalId - static MaxValue : TestLocalId - static MinValue : TestLocalId - static Parse(ReadOnlySpan, IFormatProvider) : TestLocalId - static Parse(ReadOnlySpan, IFormatProvider) : TestLocalId - static Parse(String, IFormatProvider) : TestLocalId - static TryParse(ReadOnlySpan, IFormatProvider, out TestLocalId) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out TestLocalId) : Boolean - static TryParse(String, IFormatProvider, out TestLocalId) : Boolean + static From(Int32) : TestLocalId [IPlainValueObject.From] + static MaxValue : TestLocalId [IMinMaxValue.MaxValue] + static MinValue : TestLocalId [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : TestLocalId [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : TestLocalId [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : TestLocalId [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out TestLocalId) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out TestLocalId) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out TestLocalId) : Boolean [IParsable.TryParse] static op_Equality(TestLocalId, TestLocalId) : Boolean - static op_GreaterThan(TestLocalId, TestLocalId) : Boolean - static op_GreaterThanOrEqual(TestLocalId, TestLocalId) : Boolean + static op_GreaterThan(TestLocalId, TestLocalId) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(TestLocalId, TestLocalId) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(TestLocalId, TestLocalId) : Boolean - static op_LessThan(TestLocalId, TestLocalId) : Boolean - static op_LessThanOrEqual(TestLocalId, TestLocalId) : Boolean - extension static TestLocalIdExtensions.GetValue(TestLocalId) : Int32 - extension static TestLocalIdExtensions.ValueOrNull(TestLocalId?) : Int32? + static op_LessThan(TestLocalId, TestLocalId) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(TestLocalId, TestLocalId) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static TestLocalIdExtensions.GetValue(TestLocalId) : Int32 [IValueObject.Value] + extension static TestLocalIdExtensions.ValueOrNull(TestLocalId?) : Int32? [IValueObject.Value] ThrowingCount - CompareTo(Object) : Int32 - CompareTo(ThrowingCount) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ThrowingCount) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ThrowingCount) : Boolean GetHashCode() : Int32 - Revalidate() : Result + Revalidate() : Result [IValidatedValue.Revalidate] ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6905,36 +6905,36 @@ ThrowingCount implements IValidatedValue implements IValueObject implements IValueObjectMaterializer - nested ThrowingCountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ThrowingCountTypeConverter : TypeConverter + nested ThrowingCountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValidatedValue.ThrowingCountJsonConverter] + nested ThrowingCountTypeConverter : TypeConverter [IValidatedValue.ThrowingCountTypeConverter] new() static Create(Int32) : Result - static FromKnownGood(Int32, String) : ThrowingCount - static Parse(ReadOnlySpan, IFormatProvider) : ThrowingCount - static Parse(ReadOnlySpan, IFormatProvider) : ThrowingCount - static Parse(String, IFormatProvider) : ThrowingCount - static TryFrom(Int32) : Option - static TryParse(ReadOnlySpan, IFormatProvider, out ThrowingCount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ThrowingCount) : Boolean - static TryParse(String, IFormatProvider, out ThrowingCount) : Boolean + static FromKnownGood(Int32, String) : ThrowingCount [IValidatedValue.FromKnownGood] + static Parse(ReadOnlySpan, IFormatProvider) : ThrowingCount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ThrowingCount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ThrowingCount [IParsable.Parse] + static TryFrom(Int32) : Option [IValidatedValue.TryFrom] + static TryParse(ReadOnlySpan, IFormatProvider, out ThrowingCount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ThrowingCount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ThrowingCount) : Boolean [IParsable.TryParse] static op_Equality(ThrowingCount, ThrowingCount) : Boolean - static op_GreaterThan(ThrowingCount, ThrowingCount) : Boolean - static op_GreaterThanOrEqual(ThrowingCount, ThrowingCount) : Boolean + static op_GreaterThan(ThrowingCount, ThrowingCount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ThrowingCount, ThrowingCount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ThrowingCount, ThrowingCount) : Boolean - static op_LessThan(ThrowingCount, ThrowingCount) : Boolean - static op_LessThanOrEqual(ThrowingCount, ThrowingCount) : Boolean - extension static ThrowingCountExtensions.GetValue(ThrowingCount) : Int32 - extension static ThrowingCountExtensions.ValueOrNull(ThrowingCount?) : Int32? + static op_LessThan(ThrowingCount, ThrowingCount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ThrowingCount, ThrowingCount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ThrowingCountExtensions.GetValue(ThrowingCount) : Int32 [IValueObject.Value] + extension static ThrowingCountExtensions.ValueOrNull(ThrowingCount?) : Int32? [IValueObject.Value] ThrowingDate - CompareTo(Object) : Int32 - CompareTo(ThrowingDate) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ThrowingDate) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ThrowingDate) : Boolean GetHashCode() : Int32 - Revalidate() : Result + Revalidate() : Result [IValidatedValue.Revalidate] ToString() : String - ToString(String, IFormatProvider) : String - Value : LocalDate + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : LocalDate [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6949,30 +6949,30 @@ ThrowingDate implements IValidatedValue implements IValueObject implements IValueObjectMaterializer - nested ThrowingDateJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ThrowingDateTypeConverter : TypeConverter + nested ThrowingDateJsonConverter : JsonConverter, IStoredJsonConverterSource [IValidatedValue.ThrowingDateJsonConverter] + nested ThrowingDateTypeConverter : TypeConverter [IValidatedValue.ThrowingDateTypeConverter] new() static Create(LocalDate) : Result - static FromKnownGood(LocalDate, String) : ThrowingDate - static Parse(String, IFormatProvider) : ThrowingDate - static TryFrom(LocalDate) : Option - static TryParse(String, IFormatProvider, out ThrowingDate) : Boolean + static FromKnownGood(LocalDate, String) : ThrowingDate [IValidatedValue.FromKnownGood] + static Parse(String, IFormatProvider) : ThrowingDate [IParsable.Parse] + static TryFrom(LocalDate) : Option [IValidatedValue.TryFrom] + static TryParse(String, IFormatProvider, out ThrowingDate) : Boolean [IParsable.TryParse] static op_Equality(ThrowingDate, ThrowingDate) : Boolean - static op_GreaterThan(ThrowingDate, ThrowingDate) : Boolean - static op_GreaterThanOrEqual(ThrowingDate, ThrowingDate) : Boolean + static op_GreaterThan(ThrowingDate, ThrowingDate) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ThrowingDate, ThrowingDate) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ThrowingDate, ThrowingDate) : Boolean - static op_LessThan(ThrowingDate, ThrowingDate) : Boolean - static op_LessThanOrEqual(ThrowingDate, ThrowingDate) : Boolean - extension static ThrowingDateExtensions.GetValue(ThrowingDate) : LocalDate - extension static ThrowingDateExtensions.ValueOrNull(ThrowingDate?) : LocalDate? + static op_LessThan(ThrowingDate, ThrowingDate) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ThrowingDate, ThrowingDate) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ThrowingDateExtensions.GetValue(ThrowingDate) : LocalDate [IValueObject.Value] + extension static ThrowingDateExtensions.ValueOrNull(ThrowingDate?) : LocalDate? [IValueObject.Value] ThrowingIsbn Equals(Object) : Boolean Equals(ThrowingIsbn) : Boolean GetHashCode() : Int32 - Revalidate() : Result + Revalidate() : Result [IValidatedValue.Revalidate] ToString() : String - ToString(String, IFormatProvider) : String - Value : ProbeIsbnText + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ProbeIsbnText [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -6984,26 +6984,26 @@ ThrowingIsbn implements IValidatedValue implements IValueObject implements IValueObjectMaterializer - nested ThrowingIsbnJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ThrowingIsbnTypeConverter : TypeConverter + nested ThrowingIsbnJsonConverter : JsonConverter, IStoredJsonConverterSource [IValidatedValue.ThrowingIsbnJsonConverter] + nested ThrowingIsbnTypeConverter : TypeConverter [IValidatedValue.ThrowingIsbnTypeConverter] new() static Create(ProbeIsbnText) : Result - static FromKnownGood(ProbeIsbnText, String) : ThrowingIsbn - static Parse(String, IFormatProvider) : ThrowingIsbn - static TryFrom(ProbeIsbnText) : Option - static TryParse(String, IFormatProvider, out ThrowingIsbn) : Boolean + static FromKnownGood(ProbeIsbnText, String) : ThrowingIsbn [IValidatedValue.FromKnownGood] + static Parse(String, IFormatProvider) : ThrowingIsbn [IParsable.Parse] + static TryFrom(ProbeIsbnText) : Option [IValidatedValue.TryFrom] + static TryParse(String, IFormatProvider, out ThrowingIsbn) : Boolean [IParsable.TryParse] static op_Equality(ThrowingIsbn, ThrowingIsbn) : Boolean static op_Inequality(ThrowingIsbn, ThrowingIsbn) : Boolean - extension static ThrowingIsbnExtensions.GetValue(ThrowingIsbn) : ProbeIsbnText - extension static ThrowingIsbnExtensions.ValueOrNull(ThrowingIsbn?) : ProbeIsbnText + extension static ThrowingIsbnExtensions.GetValue(ThrowingIsbn) : ProbeIsbnText [IValueObject.Value] + extension static ThrowingIsbnExtensions.ValueOrNull(ThrowingIsbn?) : ProbeIsbnText [IValueObject.Value] ThrowingSku Equals(Object) : Boolean Equals(ThrowingSku) : Boolean GetHashCode() : Int32 - Revalidate() : Result + Revalidate() : Result [IValidatedValue.Revalidate] ToString() : String - ToString(String, IFormatProvider) : String - Value : ProbeSkuText + ToString(String, IFormatProvider) : String [IFormattable.ToString] + Value : ProbeSkuText [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7015,28 +7015,28 @@ ThrowingSku implements IValidatedValue implements IValueObject implements IValueObjectMaterializer - nested ThrowingSkuJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ThrowingSkuTypeConverter : TypeConverter + nested ThrowingSkuJsonConverter : JsonConverter, IStoredJsonConverterSource [IValidatedValue.ThrowingSkuJsonConverter] + nested ThrowingSkuTypeConverter : TypeConverter [IValidatedValue.ThrowingSkuTypeConverter] new() static Create(ProbeSkuText) : Result - static FromKnownGood(ProbeSkuText, String) : ThrowingSku - static Parse(String, IFormatProvider) : ThrowingSku - static TryFrom(ProbeSkuText) : Option - static TryParse(String, IFormatProvider, out ThrowingSku) : Boolean + static FromKnownGood(ProbeSkuText, String) : ThrowingSku [IValidatedValue.FromKnownGood] + static Parse(String, IFormatProvider) : ThrowingSku [IParsable.Parse] + static TryFrom(ProbeSkuText) : Option [IValidatedValue.TryFrom] + static TryParse(String, IFormatProvider, out ThrowingSku) : Boolean [IParsable.TryParse] static op_Equality(ThrowingSku, ThrowingSku) : Boolean static op_Inequality(ThrowingSku, ThrowingSku) : Boolean - extension static ThrowingSkuExtensions.GetValue(ThrowingSku) : ProbeSkuText - extension static ThrowingSkuExtensions.ValueOrNull(ThrowingSku?) : ProbeSkuText + extension static ThrowingSkuExtensions.GetValue(ThrowingSku) : ProbeSkuText [IValueObject.Value] + extension static ThrowingSkuExtensions.ValueOrNull(ThrowingSku?) : ProbeSkuText [IValueObject.Value] ToStringOverloadedByArity - CompareTo(Object) : Int32 - CompareTo(ToStringOverloadedByArity) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ToStringOverloadedByArity) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(ToStringOverloadedByArity) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String + ToString(String, IFormatProvider) : String [IFormattable.ToString] ToString() : String - Value : String + Value : String [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7054,36 +7054,36 @@ ToStringOverloadedByArity implements IValue implements IValueObject implements IValueObjectMaterializer - nested ToStringOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ToStringOverloadedByArityTypeConverter : TypeConverter + nested ToStringOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.ToStringOverloadedByArityJsonConverter] + nested ToStringOverloadedByArityTypeConverter : TypeConverter [IValue.ToStringOverloadedByArityTypeConverter] new() - static From(String) : ToStringOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : ToStringOverloadedByArity - static Parse(String, IFormatProvider) : ToStringOverloadedByArity - static TryParse(ReadOnlySpan, IFormatProvider, out ToStringOverloadedByArity) : Boolean - static TryParse(String, IFormatProvider, out ToStringOverloadedByArity) : Boolean + static From(String) : ToStringOverloadedByArity [IPlainValueObject.From] + static Parse(ReadOnlySpan, IFormatProvider) : ToStringOverloadedByArity [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ToStringOverloadedByArity [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out ToStringOverloadedByArity) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ToStringOverloadedByArity) : Boolean [IParsable.TryParse] static op_Equality(ToStringOverloadedByArity, ToStringOverloadedByArity) : Boolean - static op_GreaterThan(ToStringOverloadedByArity, ToStringOverloadedByArity) : Boolean - static op_GreaterThanOrEqual(ToStringOverloadedByArity, ToStringOverloadedByArity) : Boolean + static op_GreaterThan(ToStringOverloadedByArity, ToStringOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ToStringOverloadedByArity, ToStringOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ToStringOverloadedByArity, ToStringOverloadedByArity) : Boolean - static op_LessThan(ToStringOverloadedByArity, ToStringOverloadedByArity) : Boolean - static op_LessThanOrEqual(ToStringOverloadedByArity, ToStringOverloadedByArity) : Boolean - extension static ToStringOverloadedByArityExtensions.GetValue(ToStringOverloadedByArity) : String - extension static ToStringOverloadedByArityExtensions.ValueOrNull(ToStringOverloadedByArity?) : String + static op_LessThan(ToStringOverloadedByArity, ToStringOverloadedByArity) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ToStringOverloadedByArity, ToStringOverloadedByArity) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ToStringOverloadedByArityExtensions.GetValue(ToStringOverloadedByArity) : String [IValueObject.Value] + extension static ToStringOverloadedByArityExtensions.ValueOrNull(ToStringOverloadedByArity?) : String [IValueObject.Value] TryFormatOverloaded - CompareTo(Object) : Int32 - CompareTo(TryFormatOverloaded) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(TryFormatOverloaded) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(TryFormatOverloaded) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String + ToString(String, IFormatProvider) : String [IFormattable.ToString] TryFormat(Span, Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] TryFormat(Span, Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7105,38 +7105,38 @@ TryFormatOverloaded implements IValue implements IValueObject implements IValueObjectMaterializer - nested TryFormatOverloadedJsonConverter : JsonConverter, IStoredJsonConverterSource - nested TryFormatOverloadedTypeConverter : TypeConverter + nested TryFormatOverloadedJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.TryFormatOverloadedJsonConverter] + nested TryFormatOverloadedTypeConverter : TypeConverter [IValue.TryFormatOverloadedTypeConverter] new() - static From(Int32) : TryFormatOverloaded - static MaxValue : TryFormatOverloaded - static MinValue : TryFormatOverloaded - static Parse(ReadOnlySpan, IFormatProvider) : TryFormatOverloaded - static Parse(ReadOnlySpan, IFormatProvider) : TryFormatOverloaded - static Parse(String, IFormatProvider) : TryFormatOverloaded - static TryParse(ReadOnlySpan, IFormatProvider, out TryFormatOverloaded) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out TryFormatOverloaded) : Boolean - static TryParse(String, IFormatProvider, out TryFormatOverloaded) : Boolean + static From(Int32) : TryFormatOverloaded [IPlainValueObject.From] + static MaxValue : TryFormatOverloaded [IMinMaxValue.MaxValue] + static MinValue : TryFormatOverloaded [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : TryFormatOverloaded [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : TryFormatOverloaded [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : TryFormatOverloaded [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out TryFormatOverloaded) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out TryFormatOverloaded) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out TryFormatOverloaded) : Boolean [IParsable.TryParse] static op_Equality(TryFormatOverloaded, TryFormatOverloaded) : Boolean - static op_GreaterThan(TryFormatOverloaded, TryFormatOverloaded) : Boolean - static op_GreaterThanOrEqual(TryFormatOverloaded, TryFormatOverloaded) : Boolean + static op_GreaterThan(TryFormatOverloaded, TryFormatOverloaded) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(TryFormatOverloaded, TryFormatOverloaded) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(TryFormatOverloaded, TryFormatOverloaded) : Boolean - static op_LessThan(TryFormatOverloaded, TryFormatOverloaded) : Boolean - static op_LessThanOrEqual(TryFormatOverloaded, TryFormatOverloaded) : Boolean - extension static TryFormatOverloadedExtensions.GetValue(TryFormatOverloaded) : Int32 - extension static TryFormatOverloadedExtensions.ValueOrNull(TryFormatOverloaded?) : Int32? + static op_LessThan(TryFormatOverloaded, TryFormatOverloaded) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(TryFormatOverloaded, TryFormatOverloaded) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static TryFormatOverloadedExtensions.GetValue(TryFormatOverloaded) : Int32 [IValueObject.Value] + extension static TryFormatOverloadedExtensions.ValueOrNull(TryFormatOverloaded?) : Int32? [IValueObject.Value] TryFromOverloaded - CompareTo(Object) : Int32 - CompareTo(TryFromOverloaded) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(TryFromOverloaded) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(TryFromOverloaded) : Boolean GetHashCode() : Int32 - Revalidate() : Result + Revalidate() : Result [IValidatedValue.Revalidate] ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7156,39 +7156,39 @@ TryFromOverloaded implements IValidatedValue implements IValueObject implements IValueObjectMaterializer - nested TryFromOverloadedJsonConverter : JsonConverter, IStoredJsonConverterSource - nested TryFromOverloadedTypeConverter : TypeConverter + nested TryFromOverloadedJsonConverter : JsonConverter, IStoredJsonConverterSource [IValidatedValue.TryFromOverloadedJsonConverter] + nested TryFromOverloadedTypeConverter : TypeConverter [IValidatedValue.TryFromOverloadedTypeConverter] new() static Create(Int32) : Result - static FromKnownGood(Int32, String) : TryFromOverloaded - static Parse(ReadOnlySpan, IFormatProvider) : TryFromOverloaded - static Parse(ReadOnlySpan, IFormatProvider) : TryFromOverloaded - static Parse(String, IFormatProvider) : TryFromOverloaded - static TryFrom(Int32) : Option + static FromKnownGood(Int32, String) : TryFromOverloaded [IValidatedValue.FromKnownGood] + static Parse(ReadOnlySpan, IFormatProvider) : TryFromOverloaded [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : TryFromOverloaded [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : TryFromOverloaded [IParsable.Parse] + static TryFrom(Int32) : Option [IValidatedValue.TryFrom] static TryFrom(in Int32) : Option static TryFrom(Int32) : Option - static TryParse(ReadOnlySpan, IFormatProvider, out TryFromOverloaded) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out TryFromOverloaded) : Boolean - static TryParse(String, IFormatProvider, out TryFromOverloaded) : Boolean + static TryParse(ReadOnlySpan, IFormatProvider, out TryFromOverloaded) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out TryFromOverloaded) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out TryFromOverloaded) : Boolean [IParsable.TryParse] static op_Equality(TryFromOverloaded, TryFromOverloaded) : Boolean - static op_GreaterThan(TryFromOverloaded, TryFromOverloaded) : Boolean - static op_GreaterThanOrEqual(TryFromOverloaded, TryFromOverloaded) : Boolean + static op_GreaterThan(TryFromOverloaded, TryFromOverloaded) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(TryFromOverloaded, TryFromOverloaded) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(TryFromOverloaded, TryFromOverloaded) : Boolean - static op_LessThan(TryFromOverloaded, TryFromOverloaded) : Boolean - static op_LessThanOrEqual(TryFromOverloaded, TryFromOverloaded) : Boolean - extension static TryFromOverloadedExtensions.GetValue(TryFromOverloaded) : Int32 - extension static TryFromOverloadedExtensions.ValueOrNull(TryFromOverloaded?) : Int32? + static op_LessThan(TryFromOverloaded, TryFromOverloaded) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(TryFromOverloaded, TryFromOverloaded) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static TryFromOverloadedExtensions.GetValue(TryFromOverloaded) : Int32 [IValueObject.Value] + extension static TryFromOverloadedExtensions.ValueOrNull(TryFromOverloaded?) : Int32? [IValueObject.Value] TryParseOverloadedByArity - CompareTo(Object) : Int32 - CompareTo(TryParseOverloadedByArity) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(TryParseOverloadedByArity) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(TryParseOverloadedByArity) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7210,38 +7210,38 @@ TryParseOverloadedByArity implements IValue implements IValueObject implements IValueObjectMaterializer - nested TryParseOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource - nested TryParseOverloadedByArityTypeConverter : TypeConverter + nested TryParseOverloadedByArityJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.TryParseOverloadedByArityJsonConverter] + nested TryParseOverloadedByArityTypeConverter : TypeConverter [IValue.TryParseOverloadedByArityTypeConverter] new() - static From(Int32) : TryParseOverloadedByArity - static MaxValue : TryParseOverloadedByArity - static MinValue : TryParseOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : TryParseOverloadedByArity - static Parse(ReadOnlySpan, IFormatProvider) : TryParseOverloadedByArity - static Parse(String, IFormatProvider) : TryParseOverloadedByArity - static TryParse(ReadOnlySpan, IFormatProvider, out TryParseOverloadedByArity) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out TryParseOverloadedByArity) : Boolean - static TryParse(String, IFormatProvider, out TryParseOverloadedByArity) : Boolean + static From(Int32) : TryParseOverloadedByArity [IPlainValueObject.From] + static MaxValue : TryParseOverloadedByArity [IMinMaxValue.MaxValue] + static MinValue : TryParseOverloadedByArity [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : TryParseOverloadedByArity [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : TryParseOverloadedByArity [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : TryParseOverloadedByArity [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out TryParseOverloadedByArity) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out TryParseOverloadedByArity) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out TryParseOverloadedByArity) : Boolean [IParsable.TryParse] static TryParse(String, IFormatProvider, out TryParseOverloadedByArity) : Boolean static op_Equality(TryParseOverloadedByArity, TryParseOverloadedByArity) : Boolean - static op_GreaterThan(TryParseOverloadedByArity, TryParseOverloadedByArity) : Boolean - static op_GreaterThanOrEqual(TryParseOverloadedByArity, TryParseOverloadedByArity) : Boolean + static op_GreaterThan(TryParseOverloadedByArity, TryParseOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(TryParseOverloadedByArity, TryParseOverloadedByArity) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(TryParseOverloadedByArity, TryParseOverloadedByArity) : Boolean - static op_LessThan(TryParseOverloadedByArity, TryParseOverloadedByArity) : Boolean - static op_LessThanOrEqual(TryParseOverloadedByArity, TryParseOverloadedByArity) : Boolean - extension static TryParseOverloadedByArityExtensions.GetValue(TryParseOverloadedByArity) : Int32 - extension static TryParseOverloadedByArityExtensions.ValueOrNull(TryParseOverloadedByArity?) : Int32? + static op_LessThan(TryParseOverloadedByArity, TryParseOverloadedByArity) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(TryParseOverloadedByArity, TryParseOverloadedByArity) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static TryParseOverloadedByArityExtensions.GetValue(TryParseOverloadedByArity) : Int32 [IValueObject.Value] + extension static TryParseOverloadedByArityExtensions.ValueOrNull(TryParseOverloadedByArity?) : Int32? [IValueObject.Value] TryParseOverloadedByValue - CompareTo(Object) : Int32 - CompareTo(TryParseOverloadedByValue) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(TryParseOverloadedByValue) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(TryParseOverloadedByValue) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7263,38 +7263,38 @@ TryParseOverloadedByValue implements IValue implements IValueObject implements IValueObjectMaterializer - nested TryParseOverloadedByValueJsonConverter : JsonConverter, IStoredJsonConverterSource - nested TryParseOverloadedByValueTypeConverter : TypeConverter + nested TryParseOverloadedByValueJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.TryParseOverloadedByValueJsonConverter] + nested TryParseOverloadedByValueTypeConverter : TypeConverter [IValue.TryParseOverloadedByValueTypeConverter] new() - static From(Int32) : TryParseOverloadedByValue - static MaxValue : TryParseOverloadedByValue - static MinValue : TryParseOverloadedByValue - static Parse(ReadOnlySpan, IFormatProvider) : TryParseOverloadedByValue - static Parse(ReadOnlySpan, IFormatProvider) : TryParseOverloadedByValue - static Parse(String, IFormatProvider) : TryParseOverloadedByValue - static TryParse(ReadOnlySpan, IFormatProvider, out TryParseOverloadedByValue) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out TryParseOverloadedByValue) : Boolean + static From(Int32) : TryParseOverloadedByValue [IPlainValueObject.From] + static MaxValue : TryParseOverloadedByValue [IMinMaxValue.MaxValue] + static MinValue : TryParseOverloadedByValue [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : TryParseOverloadedByValue [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : TryParseOverloadedByValue [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : TryParseOverloadedByValue [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out TryParseOverloadedByValue) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out TryParseOverloadedByValue) : Boolean [ISpanParsable.TryParse] static TryParse(String, IFormatProvider, TryParseOverloadedByValue) : Boolean - static TryParse(String, IFormatProvider, out TryParseOverloadedByValue) : Boolean + static TryParse(String, IFormatProvider, out TryParseOverloadedByValue) : Boolean [IParsable.TryParse] static op_Equality(TryParseOverloadedByValue, TryParseOverloadedByValue) : Boolean - static op_GreaterThan(TryParseOverloadedByValue, TryParseOverloadedByValue) : Boolean - static op_GreaterThanOrEqual(TryParseOverloadedByValue, TryParseOverloadedByValue) : Boolean + static op_GreaterThan(TryParseOverloadedByValue, TryParseOverloadedByValue) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(TryParseOverloadedByValue, TryParseOverloadedByValue) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(TryParseOverloadedByValue, TryParseOverloadedByValue) : Boolean - static op_LessThan(TryParseOverloadedByValue, TryParseOverloadedByValue) : Boolean - static op_LessThanOrEqual(TryParseOverloadedByValue, TryParseOverloadedByValue) : Boolean - extension static TryParseOverloadedByValueExtensions.GetValue(TryParseOverloadedByValue) : Int32 - extension static TryParseOverloadedByValueExtensions.ValueOrNull(TryParseOverloadedByValue?) : Int32? + static op_LessThan(TryParseOverloadedByValue, TryParseOverloadedByValue) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(TryParseOverloadedByValue, TryParseOverloadedByValue) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static TryParseOverloadedByValueExtensions.GetValue(TryParseOverloadedByValue) : Int32 [IValueObject.Value] + extension static TryParseOverloadedByValueExtensions.ValueOrNull(TryParseOverloadedByValue?) : Int32? [IValueObject.Value] UInt128Amount - CompareTo(Object) : Int32 - CompareTo(UInt128Amount) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(UInt128Amount) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(UInt128Amount) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : UInt128 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : UInt128 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7323,49 +7323,49 @@ UInt128Amount implements IValue implements IValueObject implements IValueObjectMaterializer - nested UInt128AmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested UInt128AmountTypeConverter : TypeConverter + nested UInt128AmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.UInt128AmountJsonConverter] + nested UInt128AmountTypeConverter : TypeConverter [IValue.UInt128AmountTypeConverter] new() - static From(UInt128) : UInt128Amount - static MaxValue : UInt128Amount - static MinValue : UInt128Amount - static Parse(ReadOnlySpan, IFormatProvider) : UInt128Amount - static Parse(ReadOnlySpan, IFormatProvider) : UInt128Amount - static Parse(String, IFormatProvider) : UInt128Amount - static TryParse(ReadOnlySpan, IFormatProvider, out UInt128Amount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out UInt128Amount) : Boolean - static TryParse(String, IFormatProvider, out UInt128Amount) : Boolean - static op_Addition(UInt128Amount, UInt128Amount) : UInt128Amount - static op_CheckedAddition(UInt128Amount, UInt128Amount) : UInt128Amount - static op_CheckedDivision(UInt128Amount, UInt128Amount) : UInt128Amount - static op_CheckedMultiply(UInt128Amount, UInt128Amount) : UInt128Amount - static op_CheckedSubtraction(UInt128Amount, UInt128Amount) : UInt128Amount - static op_CheckedUnaryNegation(UInt128Amount) : UInt128Amount - static op_Division(UInt128Amount, UInt128Amount) : UInt128Amount + static From(UInt128) : UInt128Amount [IPlainValueObject.From] + static MaxValue : UInt128Amount [IMinMaxValue.MaxValue] + static MinValue : UInt128Amount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : UInt128Amount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : UInt128Amount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : UInt128Amount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out UInt128Amount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out UInt128Amount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out UInt128Amount) : Boolean [IParsable.TryParse] + static op_Addition(UInt128Amount, UInt128Amount) : UInt128Amount [IAdditionOperators.op_Addition] + static op_CheckedAddition(UInt128Amount, UInt128Amount) : UInt128Amount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(UInt128Amount, UInt128Amount) : UInt128Amount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(UInt128Amount, UInt128Amount) : UInt128Amount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(UInt128Amount, UInt128Amount) : UInt128Amount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(UInt128Amount) : UInt128Amount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(UInt128Amount, UInt128Amount) : UInt128Amount [IDivisionOperators.op_Division] static op_Equality(UInt128Amount, UInt128Amount) : Boolean - static op_GreaterThan(UInt128Amount, UInt128Amount) : Boolean - static op_GreaterThanOrEqual(UInt128Amount, UInt128Amount) : Boolean + static op_GreaterThan(UInt128Amount, UInt128Amount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(UInt128Amount, UInt128Amount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(UInt128Amount, UInt128Amount) : Boolean - static op_LessThan(UInt128Amount, UInt128Amount) : Boolean - static op_LessThanOrEqual(UInt128Amount, UInt128Amount) : Boolean - static op_Modulus(UInt128Amount, UInt128Amount) : UInt128Amount - static op_Multiply(UInt128Amount, UInt128Amount) : UInt128Amount - static op_Subtraction(UInt128Amount, UInt128Amount) : UInt128Amount - static op_UnaryNegation(UInt128Amount) : UInt128Amount - static op_UnaryPlus(UInt128Amount) : UInt128Amount - extension static UInt128AmountExtensions.GetValue(UInt128Amount) : UInt128 - extension static UInt128AmountExtensions.ValueOrNull(UInt128Amount?) : UInt128? + static op_LessThan(UInt128Amount, UInt128Amount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(UInt128Amount, UInt128Amount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(UInt128Amount, UInt128Amount) : UInt128Amount [IModulusOperators.op_Modulus] + static op_Multiply(UInt128Amount, UInt128Amount) : UInt128Amount [IMultiplyOperators.op_Multiply] + static op_Subtraction(UInt128Amount, UInt128Amount) : UInt128Amount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(UInt128Amount) : UInt128Amount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(UInt128Amount) : UInt128Amount [IUnaryPlusOperators.op_UnaryPlus] + extension static UInt128AmountExtensions.GetValue(UInt128Amount) : UInt128 [IValueObject.Value] + extension static UInt128AmountExtensions.ValueOrNull(UInt128Amount?) : UInt128? [IValueObject.Value] UInt16Amount - CompareTo(Object) : Int32 - CompareTo(UInt16Amount) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(UInt16Amount) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(UInt16Amount) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : UInt16 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : UInt16 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7395,49 +7395,49 @@ UInt16Amount implements IValue implements IValueObject implements IValueObjectMaterializer - nested UInt16AmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested UInt16AmountTypeConverter : TypeConverter + nested UInt16AmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.UInt16AmountJsonConverter] + nested UInt16AmountTypeConverter : TypeConverter [IValue.UInt16AmountTypeConverter] new() - static From(UInt16) : UInt16Amount - static MaxValue : UInt16Amount - static MinValue : UInt16Amount - static Parse(ReadOnlySpan, IFormatProvider) : UInt16Amount - static Parse(ReadOnlySpan, IFormatProvider) : UInt16Amount - static Parse(String, IFormatProvider) : UInt16Amount - static TryParse(ReadOnlySpan, IFormatProvider, out UInt16Amount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out UInt16Amount) : Boolean - static TryParse(String, IFormatProvider, out UInt16Amount) : Boolean - static op_Addition(UInt16Amount, UInt16Amount) : UInt16Amount - static op_CheckedAddition(UInt16Amount, UInt16Amount) : UInt16Amount - static op_CheckedDivision(UInt16Amount, UInt16Amount) : UInt16Amount - static op_CheckedMultiply(UInt16Amount, UInt16Amount) : UInt16Amount - static op_CheckedSubtraction(UInt16Amount, UInt16Amount) : UInt16Amount - static op_CheckedUnaryNegation(UInt16Amount) : UInt16Amount - static op_Division(UInt16Amount, UInt16Amount) : UInt16Amount + static From(UInt16) : UInt16Amount [IPlainValueObject.From] + static MaxValue : UInt16Amount [IMinMaxValue.MaxValue] + static MinValue : UInt16Amount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : UInt16Amount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : UInt16Amount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : UInt16Amount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out UInt16Amount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out UInt16Amount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out UInt16Amount) : Boolean [IParsable.TryParse] + static op_Addition(UInt16Amount, UInt16Amount) : UInt16Amount [IAdditionOperators.op_Addition] + static op_CheckedAddition(UInt16Amount, UInt16Amount) : UInt16Amount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(UInt16Amount, UInt16Amount) : UInt16Amount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(UInt16Amount, UInt16Amount) : UInt16Amount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(UInt16Amount, UInt16Amount) : UInt16Amount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(UInt16Amount) : UInt16Amount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(UInt16Amount, UInt16Amount) : UInt16Amount [IDivisionOperators.op_Division] static op_Equality(UInt16Amount, UInt16Amount) : Boolean - static op_GreaterThan(UInt16Amount, UInt16Amount) : Boolean - static op_GreaterThanOrEqual(UInt16Amount, UInt16Amount) : Boolean + static op_GreaterThan(UInt16Amount, UInt16Amount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(UInt16Amount, UInt16Amount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(UInt16Amount, UInt16Amount) : Boolean - static op_LessThan(UInt16Amount, UInt16Amount) : Boolean - static op_LessThanOrEqual(UInt16Amount, UInt16Amount) : Boolean - static op_Modulus(UInt16Amount, UInt16Amount) : UInt16Amount - static op_Multiply(UInt16Amount, UInt16Amount) : UInt16Amount - static op_Subtraction(UInt16Amount, UInt16Amount) : UInt16Amount - static op_UnaryNegation(UInt16Amount) : UInt16Amount - static op_UnaryPlus(UInt16Amount) : UInt16Amount - extension static UInt16AmountExtensions.GetValue(UInt16Amount) : UInt16 - extension static UInt16AmountExtensions.ValueOrNull(UInt16Amount?) : UInt16? + static op_LessThan(UInt16Amount, UInt16Amount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(UInt16Amount, UInt16Amount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(UInt16Amount, UInt16Amount) : UInt16Amount [IModulusOperators.op_Modulus] + static op_Multiply(UInt16Amount, UInt16Amount) : UInt16Amount [IMultiplyOperators.op_Multiply] + static op_Subtraction(UInt16Amount, UInt16Amount) : UInt16Amount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(UInt16Amount) : UInt16Amount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(UInt16Amount) : UInt16Amount [IUnaryPlusOperators.op_UnaryPlus] + extension static UInt16AmountExtensions.GetValue(UInt16Amount) : UInt16 [IValueObject.Value] + extension static UInt16AmountExtensions.ValueOrNull(UInt16Amount?) : UInt16? [IValueObject.Value] UInt32Amount - CompareTo(Object) : Int32 - CompareTo(UInt32Amount) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(UInt32Amount) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(UInt32Amount) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : UInt32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : UInt32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7467,49 +7467,49 @@ UInt32Amount implements IValue implements IValueObject implements IValueObjectMaterializer - nested UInt32AmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested UInt32AmountTypeConverter : TypeConverter + nested UInt32AmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.UInt32AmountJsonConverter] + nested UInt32AmountTypeConverter : TypeConverter [IValue.UInt32AmountTypeConverter] new() - static From(UInt32) : UInt32Amount - static MaxValue : UInt32Amount - static MinValue : UInt32Amount - static Parse(ReadOnlySpan, IFormatProvider) : UInt32Amount - static Parse(ReadOnlySpan, IFormatProvider) : UInt32Amount - static Parse(String, IFormatProvider) : UInt32Amount - static TryParse(ReadOnlySpan, IFormatProvider, out UInt32Amount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out UInt32Amount) : Boolean - static TryParse(String, IFormatProvider, out UInt32Amount) : Boolean - static op_Addition(UInt32Amount, UInt32Amount) : UInt32Amount - static op_CheckedAddition(UInt32Amount, UInt32Amount) : UInt32Amount - static op_CheckedDivision(UInt32Amount, UInt32Amount) : UInt32Amount - static op_CheckedMultiply(UInt32Amount, UInt32Amount) : UInt32Amount - static op_CheckedSubtraction(UInt32Amount, UInt32Amount) : UInt32Amount - static op_CheckedUnaryNegation(UInt32Amount) : UInt32Amount - static op_Division(UInt32Amount, UInt32Amount) : UInt32Amount + static From(UInt32) : UInt32Amount [IPlainValueObject.From] + static MaxValue : UInt32Amount [IMinMaxValue.MaxValue] + static MinValue : UInt32Amount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : UInt32Amount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : UInt32Amount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : UInt32Amount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out UInt32Amount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out UInt32Amount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out UInt32Amount) : Boolean [IParsable.TryParse] + static op_Addition(UInt32Amount, UInt32Amount) : UInt32Amount [IAdditionOperators.op_Addition] + static op_CheckedAddition(UInt32Amount, UInt32Amount) : UInt32Amount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(UInt32Amount, UInt32Amount) : UInt32Amount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(UInt32Amount, UInt32Amount) : UInt32Amount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(UInt32Amount, UInt32Amount) : UInt32Amount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(UInt32Amount) : UInt32Amount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(UInt32Amount, UInt32Amount) : UInt32Amount [IDivisionOperators.op_Division] static op_Equality(UInt32Amount, UInt32Amount) : Boolean - static op_GreaterThan(UInt32Amount, UInt32Amount) : Boolean - static op_GreaterThanOrEqual(UInt32Amount, UInt32Amount) : Boolean + static op_GreaterThan(UInt32Amount, UInt32Amount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(UInt32Amount, UInt32Amount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(UInt32Amount, UInt32Amount) : Boolean - static op_LessThan(UInt32Amount, UInt32Amount) : Boolean - static op_LessThanOrEqual(UInt32Amount, UInt32Amount) : Boolean - static op_Modulus(UInt32Amount, UInt32Amount) : UInt32Amount - static op_Multiply(UInt32Amount, UInt32Amount) : UInt32Amount - static op_Subtraction(UInt32Amount, UInt32Amount) : UInt32Amount - static op_UnaryNegation(UInt32Amount) : UInt32Amount - static op_UnaryPlus(UInt32Amount) : UInt32Amount - extension static UInt32AmountExtensions.GetValue(UInt32Amount) : UInt32 - extension static UInt32AmountExtensions.ValueOrNull(UInt32Amount?) : UInt32? + static op_LessThan(UInt32Amount, UInt32Amount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(UInt32Amount, UInt32Amount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(UInt32Amount, UInt32Amount) : UInt32Amount [IModulusOperators.op_Modulus] + static op_Multiply(UInt32Amount, UInt32Amount) : UInt32Amount [IMultiplyOperators.op_Multiply] + static op_Subtraction(UInt32Amount, UInt32Amount) : UInt32Amount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(UInt32Amount) : UInt32Amount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(UInt32Amount) : UInt32Amount [IUnaryPlusOperators.op_UnaryPlus] + extension static UInt32AmountExtensions.GetValue(UInt32Amount) : UInt32 [IValueObject.Value] + extension static UInt32AmountExtensions.ValueOrNull(UInt32Amount?) : UInt32? [IValueObject.Value] UInt64Amount - CompareTo(Object) : Int32 - CompareTo(UInt64Amount) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(UInt64Amount) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(UInt64Amount) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : UInt64 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : UInt64 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7539,49 +7539,49 @@ UInt64Amount implements IValue implements IValueObject implements IValueObjectMaterializer - nested UInt64AmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested UInt64AmountTypeConverter : TypeConverter + nested UInt64AmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.UInt64AmountJsonConverter] + nested UInt64AmountTypeConverter : TypeConverter [IValue.UInt64AmountTypeConverter] new() - static From(UInt64) : UInt64Amount - static MaxValue : UInt64Amount - static MinValue : UInt64Amount - static Parse(ReadOnlySpan, IFormatProvider) : UInt64Amount - static Parse(ReadOnlySpan, IFormatProvider) : UInt64Amount - static Parse(String, IFormatProvider) : UInt64Amount - static TryParse(ReadOnlySpan, IFormatProvider, out UInt64Amount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out UInt64Amount) : Boolean - static TryParse(String, IFormatProvider, out UInt64Amount) : Boolean - static op_Addition(UInt64Amount, UInt64Amount) : UInt64Amount - static op_CheckedAddition(UInt64Amount, UInt64Amount) : UInt64Amount - static op_CheckedDivision(UInt64Amount, UInt64Amount) : UInt64Amount - static op_CheckedMultiply(UInt64Amount, UInt64Amount) : UInt64Amount - static op_CheckedSubtraction(UInt64Amount, UInt64Amount) : UInt64Amount - static op_CheckedUnaryNegation(UInt64Amount) : UInt64Amount - static op_Division(UInt64Amount, UInt64Amount) : UInt64Amount + static From(UInt64) : UInt64Amount [IPlainValueObject.From] + static MaxValue : UInt64Amount [IMinMaxValue.MaxValue] + static MinValue : UInt64Amount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : UInt64Amount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : UInt64Amount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : UInt64Amount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out UInt64Amount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out UInt64Amount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out UInt64Amount) : Boolean [IParsable.TryParse] + static op_Addition(UInt64Amount, UInt64Amount) : UInt64Amount [IAdditionOperators.op_Addition] + static op_CheckedAddition(UInt64Amount, UInt64Amount) : UInt64Amount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(UInt64Amount, UInt64Amount) : UInt64Amount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(UInt64Amount, UInt64Amount) : UInt64Amount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(UInt64Amount, UInt64Amount) : UInt64Amount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(UInt64Amount) : UInt64Amount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(UInt64Amount, UInt64Amount) : UInt64Amount [IDivisionOperators.op_Division] static op_Equality(UInt64Amount, UInt64Amount) : Boolean - static op_GreaterThan(UInt64Amount, UInt64Amount) : Boolean - static op_GreaterThanOrEqual(UInt64Amount, UInt64Amount) : Boolean + static op_GreaterThan(UInt64Amount, UInt64Amount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(UInt64Amount, UInt64Amount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(UInt64Amount, UInt64Amount) : Boolean - static op_LessThan(UInt64Amount, UInt64Amount) : Boolean - static op_LessThanOrEqual(UInt64Amount, UInt64Amount) : Boolean - static op_Modulus(UInt64Amount, UInt64Amount) : UInt64Amount - static op_Multiply(UInt64Amount, UInt64Amount) : UInt64Amount - static op_Subtraction(UInt64Amount, UInt64Amount) : UInt64Amount - static op_UnaryNegation(UInt64Amount) : UInt64Amount - static op_UnaryPlus(UInt64Amount) : UInt64Amount - extension static UInt64AmountExtensions.GetValue(UInt64Amount) : UInt64 - extension static UInt64AmountExtensions.ValueOrNull(UInt64Amount?) : UInt64? + static op_LessThan(UInt64Amount, UInt64Amount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(UInt64Amount, UInt64Amount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(UInt64Amount, UInt64Amount) : UInt64Amount [IModulusOperators.op_Modulus] + static op_Multiply(UInt64Amount, UInt64Amount) : UInt64Amount [IMultiplyOperators.op_Multiply] + static op_Subtraction(UInt64Amount, UInt64Amount) : UInt64Amount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(UInt64Amount) : UInt64Amount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(UInt64Amount) : UInt64Amount [IUnaryPlusOperators.op_UnaryPlus] + extension static UInt64AmountExtensions.GetValue(UInt64Amount) : UInt64 [IValueObject.Value] + extension static UInt64AmountExtensions.ValueOrNull(UInt64Amount?) : UInt64? [IValueObject.Value] UIntPtrAmount - CompareTo(Object) : Int32 - CompareTo(UIntPtrAmount) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(UIntPtrAmount) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(UIntPtrAmount) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : UIntPtr + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : UIntPtr [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7610,49 +7610,49 @@ UIntPtrAmount implements IValue implements IValueObject implements IValueObjectMaterializer - nested UIntPtrAmountJsonConverter : JsonConverter, IStoredJsonConverterSource - nested UIntPtrAmountTypeConverter : TypeConverter + nested UIntPtrAmountJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.UIntPtrAmountJsonConverter] + nested UIntPtrAmountTypeConverter : TypeConverter [IValue.UIntPtrAmountTypeConverter] new() - static From(UIntPtr) : UIntPtrAmount - static MaxValue : UIntPtrAmount - static MinValue : UIntPtrAmount - static Parse(ReadOnlySpan, IFormatProvider) : UIntPtrAmount - static Parse(ReadOnlySpan, IFormatProvider) : UIntPtrAmount - static Parse(String, IFormatProvider) : UIntPtrAmount - static TryParse(ReadOnlySpan, IFormatProvider, out UIntPtrAmount) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out UIntPtrAmount) : Boolean - static TryParse(String, IFormatProvider, out UIntPtrAmount) : Boolean - static op_Addition(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount - static op_CheckedAddition(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount - static op_CheckedDivision(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount - static op_CheckedMultiply(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount - static op_CheckedSubtraction(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount - static op_CheckedUnaryNegation(UIntPtrAmount) : UIntPtrAmount - static op_Division(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount + static From(UIntPtr) : UIntPtrAmount [IPlainValueObject.From] + static MaxValue : UIntPtrAmount [IMinMaxValue.MaxValue] + static MinValue : UIntPtrAmount [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : UIntPtrAmount [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : UIntPtrAmount [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : UIntPtrAmount [IParsable.Parse] + static TryParse(ReadOnlySpan, IFormatProvider, out UIntPtrAmount) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out UIntPtrAmount) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out UIntPtrAmount) : Boolean [IParsable.TryParse] + static op_Addition(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount [IAdditionOperators.op_Addition] + static op_CheckedAddition(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount [IAdditionOperators.op_CheckedAddition] + static op_CheckedDivision(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount [IDivisionOperators.op_CheckedDivision] + static op_CheckedMultiply(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount [IMultiplyOperators.op_CheckedMultiply] + static op_CheckedSubtraction(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount [ISubtractionOperators.op_CheckedSubtraction] + static op_CheckedUnaryNegation(UIntPtrAmount) : UIntPtrAmount [IUnaryNegationOperators.op_CheckedUnaryNegation] + static op_Division(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount [IDivisionOperators.op_Division] static op_Equality(UIntPtrAmount, UIntPtrAmount) : Boolean - static op_GreaterThan(UIntPtrAmount, UIntPtrAmount) : Boolean - static op_GreaterThanOrEqual(UIntPtrAmount, UIntPtrAmount) : Boolean + static op_GreaterThan(UIntPtrAmount, UIntPtrAmount) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(UIntPtrAmount, UIntPtrAmount) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(UIntPtrAmount, UIntPtrAmount) : Boolean - static op_LessThan(UIntPtrAmount, UIntPtrAmount) : Boolean - static op_LessThanOrEqual(UIntPtrAmount, UIntPtrAmount) : Boolean - static op_Modulus(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount - static op_Multiply(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount - static op_Subtraction(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount - static op_UnaryNegation(UIntPtrAmount) : UIntPtrAmount - static op_UnaryPlus(UIntPtrAmount) : UIntPtrAmount - extension static UIntPtrAmountExtensions.GetValue(UIntPtrAmount) : UIntPtr - extension static UIntPtrAmountExtensions.ValueOrNull(UIntPtrAmount?) : UIntPtr? + static op_LessThan(UIntPtrAmount, UIntPtrAmount) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(UIntPtrAmount, UIntPtrAmount) : Boolean [IComparisonOperators.op_LessThanOrEqual] + static op_Modulus(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount [IModulusOperators.op_Modulus] + static op_Multiply(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount [IMultiplyOperators.op_Multiply] + static op_Subtraction(UIntPtrAmount, UIntPtrAmount) : UIntPtrAmount [ISubtractionOperators.op_Subtraction] + static op_UnaryNegation(UIntPtrAmount) : UIntPtrAmount [IUnaryNegationOperators.op_UnaryNegation] + static op_UnaryPlus(UIntPtrAmount) : UIntPtrAmount [IUnaryPlusOperators.op_UnaryPlus] + extension static UIntPtrAmountExtensions.GetValue(UIntPtrAmount) : UIntPtr [IValueObject.Value] + extension static UIntPtrAmountExtensions.ValueOrNull(UIntPtrAmount?) : UIntPtr? [IValueObject.Value] Utf8ParseOverloaded - CompareTo(Object) : Int32 - CompareTo(Utf8ParseOverloaded) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(Utf8ParseOverloaded) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(Utf8ParseOverloaded) : Boolean GetHashCode() : Int32 ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7674,42 +7674,42 @@ Utf8ParseOverloaded implements IValue implements IValueObject implements IValueObjectMaterializer - nested Utf8ParseOverloadedJsonConverter : JsonConverter, IStoredJsonConverterSource - nested Utf8ParseOverloadedTypeConverter : TypeConverter + nested Utf8ParseOverloadedJsonConverter : JsonConverter, IStoredJsonConverterSource [IValue.Utf8ParseOverloadedJsonConverter] + nested Utf8ParseOverloadedTypeConverter : TypeConverter [IValue.Utf8ParseOverloadedTypeConverter] new() - static From(Int32) : Utf8ParseOverloaded - static MaxValue : Utf8ParseOverloaded - static MinValue : Utf8ParseOverloaded - static Parse(ReadOnlySpan, IFormatProvider) : Utf8ParseOverloaded - static Parse(ReadOnlySpan, IFormatProvider) : Utf8ParseOverloaded - static Parse(String, IFormatProvider) : Utf8ParseOverloaded + static From(Int32) : Utf8ParseOverloaded [IPlainValueObject.From] + static MaxValue : Utf8ParseOverloaded [IMinMaxValue.MaxValue] + static MinValue : Utf8ParseOverloaded [IMinMaxValue.MinValue] + static Parse(ReadOnlySpan, IFormatProvider) : Utf8ParseOverloaded [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : Utf8ParseOverloaded [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : Utf8ParseOverloaded [IParsable.Parse] static Parse(ReadOnlySpan, IFormatProvider) : Utf8ParseOverloaded static TryParse(ReadOnlySpan, IFormatProvider, Utf8ParseOverloaded) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out Utf8ParseOverloaded) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out Utf8ParseOverloaded) : Boolean - static TryParse(String, IFormatProvider, out Utf8ParseOverloaded) : Boolean + static TryParse(ReadOnlySpan, IFormatProvider, out Utf8ParseOverloaded) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out Utf8ParseOverloaded) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out Utf8ParseOverloaded) : Boolean [IParsable.TryParse] static op_Equality(Utf8ParseOverloaded, Utf8ParseOverloaded) : Boolean - static op_GreaterThan(Utf8ParseOverloaded, Utf8ParseOverloaded) : Boolean - static op_GreaterThanOrEqual(Utf8ParseOverloaded, Utf8ParseOverloaded) : Boolean + static op_GreaterThan(Utf8ParseOverloaded, Utf8ParseOverloaded) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(Utf8ParseOverloaded, Utf8ParseOverloaded) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(Utf8ParseOverloaded, Utf8ParseOverloaded) : Boolean - static op_LessThan(Utf8ParseOverloaded, Utf8ParseOverloaded) : Boolean - static op_LessThanOrEqual(Utf8ParseOverloaded, Utf8ParseOverloaded) : Boolean - extension static Utf8ParseOverloadedExtensions.GetValue(Utf8ParseOverloaded) : Int32 - extension static Utf8ParseOverloadedExtensions.ValueOrNull(Utf8ParseOverloaded?) : Int32? + static op_LessThan(Utf8ParseOverloaded, Utf8ParseOverloaded) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(Utf8ParseOverloaded, Utf8ParseOverloaded) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static Utf8ParseOverloadedExtensions.GetValue(Utf8ParseOverloaded) : Int32 [IValueObject.Value] + extension static Utf8ParseOverloadedExtensions.ValueOrNull(Utf8ParseOverloaded?) : Int32? [IValueObject.Value] ValidatedOverASeamOverloadingBase $() : ValidatedOverASeamOverloadingBase - CompareTo(Object) : Int32 - CompareTo(ValidatedOverASeamOverloadingBase) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ValidatedOverASeamOverloadingBase) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(SeamOverloadingBase) : Boolean Equals(ValidatedOverASeamOverloadingBase) : Boolean GetHashCode() : Int32 - Revalidate() : Result + Revalidate() : Result [IValidatedValue.Revalidate] ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7731,39 +7731,39 @@ ValidatedOverASeamOverloadingBase implements IValidatedValue implements IValueObject implements IValueObjectMaterializer - nested ValidatedOverASeamOverloadingBaseJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ValidatedOverASeamOverloadingBaseTypeConverter : TypeConverter + nested ValidatedOverASeamOverloadingBaseJsonConverter : JsonConverter, IStoredJsonConverterSource [IValidatedValue.ValidatedOverASeamOverloadingBaseJsonConverter] + nested ValidatedOverASeamOverloadingBaseTypeConverter : TypeConverter [IValidatedValue.ValidatedOverASeamOverloadingBaseTypeConverter] static Create(Int32) : Result - static FromKnownGood(Int32, String) : ValidatedOverASeamOverloadingBase - static Parse(ReadOnlySpan, IFormatProvider) : ValidatedOverASeamOverloadingBase - static Parse(ReadOnlySpan, IFormatProvider) : ValidatedOverASeamOverloadingBase - static Parse(String, IFormatProvider) : ValidatedOverASeamOverloadingBase - static TryFrom(Int32) : Option - static TryParse(ReadOnlySpan, IFormatProvider, out ValidatedOverASeamOverloadingBase) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ValidatedOverASeamOverloadingBase) : Boolean - static TryParse(String, IFormatProvider, out ValidatedOverASeamOverloadingBase) : Boolean + static FromKnownGood(Int32, String) : ValidatedOverASeamOverloadingBase [IValidatedValue.FromKnownGood] + static Parse(ReadOnlySpan, IFormatProvider) : ValidatedOverASeamOverloadingBase [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ValidatedOverASeamOverloadingBase [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ValidatedOverASeamOverloadingBase [IParsable.Parse] + static TryFrom(Int32) : Option [IValidatedValue.TryFrom] + static TryParse(ReadOnlySpan, IFormatProvider, out ValidatedOverASeamOverloadingBase) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ValidatedOverASeamOverloadingBase) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ValidatedOverASeamOverloadingBase) : Boolean [IParsable.TryParse] static op_Equality(ValidatedOverASeamOverloadingBase, ValidatedOverASeamOverloadingBase) : Boolean - static op_GreaterThan(ValidatedOverASeamOverloadingBase, ValidatedOverASeamOverloadingBase) : Boolean - static op_GreaterThanOrEqual(ValidatedOverASeamOverloadingBase, ValidatedOverASeamOverloadingBase) : Boolean + static op_GreaterThan(ValidatedOverASeamOverloadingBase, ValidatedOverASeamOverloadingBase) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ValidatedOverASeamOverloadingBase, ValidatedOverASeamOverloadingBase) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ValidatedOverASeamOverloadingBase, ValidatedOverASeamOverloadingBase) : Boolean - static op_LessThan(ValidatedOverASeamOverloadingBase, ValidatedOverASeamOverloadingBase) : Boolean - static op_LessThanOrEqual(ValidatedOverASeamOverloadingBase, ValidatedOverASeamOverloadingBase) : Boolean - extension static ValidatedOverASeamOverloadingBaseExtensions.GetValue(ValidatedOverASeamOverloadingBase) : Int32 - extension static ValidatedOverASeamOverloadingBaseExtensions.ValueOrNull(ValidatedOverASeamOverloadingBase) : Int32? + static op_LessThan(ValidatedOverASeamOverloadingBase, ValidatedOverASeamOverloadingBase) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ValidatedOverASeamOverloadingBase, ValidatedOverASeamOverloadingBase) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ValidatedOverASeamOverloadingBaseExtensions.GetValue(ValidatedOverASeamOverloadingBase) : Int32 [IValueObject.Value] + extension static ValidatedOverASeamOverloadingBaseExtensions.ValueOrNull(ValidatedOverASeamOverloadingBase) : Int32? [IValueObject.Value] ValidatedOverPrivateNames $() : ValidatedOverPrivateNames - CompareTo(Object) : Int32 - CompareTo(ValidatedOverPrivateNames) : Int32 + CompareTo(Object) : Int32 [IComparable.CompareTo] + CompareTo(ValidatedOverPrivateNames) : Int32 [IComparable.CompareTo] Equals(Object) : Boolean Equals(PrivateNamesBase) : Boolean Equals(ValidatedOverPrivateNames) : Boolean GetHashCode() : Int32 - Revalidate() : Result + Revalidate() : Result [IValidatedValue.Revalidate] ToString() : String - ToString(String, IFormatProvider) : String - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean - Value : Int32 + ToString(String, IFormatProvider) : String [IFormattable.ToString] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [IUtf8SpanFormattable.TryFormat] + TryFormat(Span, out Int32, ReadOnlySpan, IFormatProvider) : Boolean [ISpanFormattable.TryFormat] + Value : Int32 [IValueObject.Value] attribute CompilerGeneratedAttribute attribute GeneratedValueObjectAttribute attribute JsonConverterAttribute @@ -7785,22 +7785,22 @@ ValidatedOverPrivateNames implements IValidatedValue implements IValueObject implements IValueObjectMaterializer - nested ValidatedOverPrivateNamesJsonConverter : JsonConverter, IStoredJsonConverterSource - nested ValidatedOverPrivateNamesTypeConverter : TypeConverter + nested ValidatedOverPrivateNamesJsonConverter : JsonConverter, IStoredJsonConverterSource [IValidatedValue.ValidatedOverPrivateNamesJsonConverter] + nested ValidatedOverPrivateNamesTypeConverter : TypeConverter [IValidatedValue.ValidatedOverPrivateNamesTypeConverter] static Create(Int32) : Result - static FromKnownGood(Int32, String) : ValidatedOverPrivateNames - static Parse(ReadOnlySpan, IFormatProvider) : ValidatedOverPrivateNames - static Parse(ReadOnlySpan, IFormatProvider) : ValidatedOverPrivateNames - static Parse(String, IFormatProvider) : ValidatedOverPrivateNames - static TryFrom(Int32) : Option - static TryParse(ReadOnlySpan, IFormatProvider, out ValidatedOverPrivateNames) : Boolean - static TryParse(ReadOnlySpan, IFormatProvider, out ValidatedOverPrivateNames) : Boolean - static TryParse(String, IFormatProvider, out ValidatedOverPrivateNames) : Boolean + static FromKnownGood(Int32, String) : ValidatedOverPrivateNames [IValidatedValue.FromKnownGood] + static Parse(ReadOnlySpan, IFormatProvider) : ValidatedOverPrivateNames [IUtf8SpanParsable.Parse] + static Parse(ReadOnlySpan, IFormatProvider) : ValidatedOverPrivateNames [ISpanParsable.Parse] + static Parse(String, IFormatProvider) : ValidatedOverPrivateNames [IParsable.Parse] + static TryFrom(Int32) : Option [IValidatedValue.TryFrom] + static TryParse(ReadOnlySpan, IFormatProvider, out ValidatedOverPrivateNames) : Boolean [IUtf8SpanParsable.TryParse] + static TryParse(ReadOnlySpan, IFormatProvider, out ValidatedOverPrivateNames) : Boolean [ISpanParsable.TryParse] + static TryParse(String, IFormatProvider, out ValidatedOverPrivateNames) : Boolean [IParsable.TryParse] static op_Equality(ValidatedOverPrivateNames, ValidatedOverPrivateNames) : Boolean - static op_GreaterThan(ValidatedOverPrivateNames, ValidatedOverPrivateNames) : Boolean - static op_GreaterThanOrEqual(ValidatedOverPrivateNames, ValidatedOverPrivateNames) : Boolean + static op_GreaterThan(ValidatedOverPrivateNames, ValidatedOverPrivateNames) : Boolean [IComparisonOperators.op_GreaterThan] + static op_GreaterThanOrEqual(ValidatedOverPrivateNames, ValidatedOverPrivateNames) : Boolean [IComparisonOperators.op_GreaterThanOrEqual] static op_Inequality(ValidatedOverPrivateNames, ValidatedOverPrivateNames) : Boolean - static op_LessThan(ValidatedOverPrivateNames, ValidatedOverPrivateNames) : Boolean - static op_LessThanOrEqual(ValidatedOverPrivateNames, ValidatedOverPrivateNames) : Boolean - extension static ValidatedOverPrivateNamesExtensions.GetValue(ValidatedOverPrivateNames) : Int32 - extension static ValidatedOverPrivateNamesExtensions.ValueOrNull(ValidatedOverPrivateNames) : Int32? + static op_LessThan(ValidatedOverPrivateNames, ValidatedOverPrivateNames) : Boolean [IComparisonOperators.op_LessThan] + static op_LessThanOrEqual(ValidatedOverPrivateNames, ValidatedOverPrivateNames) : Boolean [IComparisonOperators.op_LessThanOrEqual] + extension static ValidatedOverPrivateNamesExtensions.GetValue(ValidatedOverPrivateNames) : Int32 [IValueObject.Value] + extension static ValidatedOverPrivateNamesExtensions.ValueOrNull(ValidatedOverPrivateNames) : Int32? [IValueObject.Value] diff --git a/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurfaceTests.cs b/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurfaceTests.cs index cac93cc..d6e1cc2 100644 --- a/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurfaceTests.cs +++ b/test/CodoMetis.TypeKit.Generators.Tests/GeneratedSurfaceTests.cs @@ -1,6 +1,7 @@ using System.Reflection; using System.Runtime.CompilerServices; using System.Text; +using CodoMetis.TypeKit.CompilerServices; using CodoMetis.TypeKit.Generators.Probes; using CodoMetis.TypeKit.ValueObjects; @@ -75,7 +76,7 @@ private static IEnumerable Lines(Type type) => [ .. type.GetInterfaces().Select(i => $"implements {Display(i)}"), .. type.GetCustomAttributesData().Where(IsDeclared).Select(attribute => $"attribute {Display(attribute.AttributeType)}"), - .. type.GetNestedTypes().Select(nested => $"nested {nested.Name} : {string.Join(", ", [Display(nested.BaseType!), .. nested.GetInterfaces().Where(i => !i.IsAssignableFrom(nested.BaseType)).Select(Display)])}"), + .. type.GetNestedTypes().Select(nested => $"nested {nested.Name} : {string.Join(", ", [Display(nested.BaseType!), .. nested.GetInterfaces().Where(i => !i.IsAssignableFrom(nested.BaseType)).Select(Display)])}{Generated(nested)}"), .. Members(type) ]; @@ -91,22 +92,29 @@ private static IEnumerable Companions(Assembly assembly, Type valueObjec .Where(method => method.IsDefined(typeof(ExtensionAttribute), false) && method.GetParameters()[0].ParameterType is var extended && (extended == valueObject || Nullable.GetUnderlyingType(extended) == valueObject)) - .Select(method => $"{(method.IsPublic ? "" : "internal ")}static {method.DeclaringType!.Name}.{method.Name}({Parameters(method)}) : {Display(method.ReturnType)}"); + .Select(method => $"{(method.IsPublic ? "" : "internal ")}static {method.DeclaringType!.Name}.{method.Name}({Parameters(method)}) : {Display(method.ReturnType)}{Generated(method)}"); private static IEnumerable Members(Type type) { const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly; foreach (var constructor in type.GetConstructors(flags)) - yield return $"new({Parameters(constructor)})"; + yield return $"new({Parameters(constructor)}){Generated(constructor)}"; foreach (var property in type.GetProperties(flags)) - yield return $"{Static(property.GetMethod!)}{property.Name} : {Display(property.PropertyType)}"; + yield return $"{Static(property.GetMethod!)}{property.Name} : {Display(property.PropertyType)}{Generated(property)}"; foreach (var method in type.GetMethods(flags).Where(method => !method.IsSpecialName || method.Name.StartsWith("op_", StringComparison.Ordinal))) - yield return $"{Static(method)}{method.Name}{TypeParameters(method)}({Parameters(method)}) : {Display(method.ReturnType)}"; + yield return $"{Static(method)}{method.Name}{TypeParameters(method)}({Parameters(method)}) : {Display(method.ReturnType)}{Generated(method)}"; } + /// + /// The contract member a generated member names in its , so that a + /// member the generators introduce without it, or name by another contract, shows up as a diff (decision 128). + /// + private static string Generated(MemberInfo member) => + member.GetCustomAttribute() is { } generated ? $" [{Display(generated.Contract)}.{generated.Member}]" : ""; + /// /// Leaves out the compiler's own bookkeeping ([Nullable], [IsReadOnly]), which varies /// between compiler versions, but keeps [CompilerGenerated], which the aspects put there. diff --git a/test/oracles/surface-waivers.json b/test/oracles/surface-waivers.json index 5d9dfe3..646e2e4 100644 --- a/test/oracles/surface-waivers.json +++ b/test/oracles/surface-waivers.json @@ -9,6 +9,7 @@ "ClosedSetAttribute..ctor": "a constraint attribute's constructor; what it constrains is CMTK0010's, held by the analyzer tests", "GeneratedClosedSetAttribute.*": "plumbing the generators write on a closed set, read by the satellites through Accept", "GeneratedValueObjectAttribute.*": "plumbing the generators write on a value object, read by the satellites through Accept", + "GeneratedMemberAttribute.*": "plumbing the generators write on every member they introduce, naming its contract; that each carries it and no hand-written one does is GeneratedMemberAttributeTests', and no document promises more yet (decision 128)", "GeneratedClosedSets.*": "refusal helpers that generated closed-set code calls; what they refuse is claimed through Parse and the JSON reads", "IClosedSetVisitor.Visit": "the visitor GeneratedClosedSetAttribute.Accept calls, plumbing", "IValueObjectVisitor.Visit": "the visitor GeneratedValueObjectAttribute.Accept calls, plumbing",